khronosfws/openmax_al/src/engine/xaaudiodecodercapabilitiesitf.c
changeset 33 5e8b14bae8c3
parent 28 ebf79c79991a
child 36 73253677b50a
equal deleted inserted replaced
28:ebf79c79991a 33:5e8b14bae8c3
     1 /*
       
     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3  * All rights reserved.
       
     4  * This component and the accompanying materials are made available
       
     5  * under the terms of "Eclipse Public License v1.0"
       
     6  * which accompanies this distribution, and is available
       
     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8  *
       
     9  * Initial Contributors:
       
    10  * Nokia Corporation - initial contribution.
       
    11  *
       
    12  * Contributors:
       
    13  *
       
    14  * Description: Audio Encoder Capabilities Interface Implementation
       
    15  *
       
    16  */
       
    17 
       
    18 #include <stdio.h>
       
    19 #include <stdlib.h>
       
    20 #include <assert.h>
       
    21 #include <string.h>
       
    22 
       
    23 #include "xaglobals.h"
       
    24 #include "xaadptbasectx.h"
       
    25 #include "xaaudiodecodercapabilitiesitf.h"
       
    26 #include "xacapabilitiesmgr.h"
       
    27 /* XAAudioDecoderCapabilitiesItfImpl* GetImpl
       
    28  * Description: Validate interface pointer and cast it to implementation pointer.
       
    29  */
       
    30 static XAAudioDecoderCapabilitiesItfImpl* GetImpl(
       
    31         XAAudioDecoderCapabilitiesItf self)
       
    32     {
       
    33     if (self)
       
    34         {
       
    35         XAAudioDecoderCapabilitiesItfImpl* impl =
       
    36                 (XAAudioDecoderCapabilitiesItfImpl*) (*self);
       
    37         if (impl && (impl == impl->self))
       
    38             {
       
    39             return impl;
       
    40             }
       
    41         }
       
    42     return NULL;
       
    43     }
       
    44 
       
    45 /*****************************************************************************
       
    46  * Base interface XAAudioDecoderCapabilitiesItf implementation
       
    47  *****************************************************************************/
       
    48 
       
    49 /* XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders
       
    50  * Description: Retrieves the available audio decoders.
       
    51  */
       
    52 XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders(
       
    53         XAAudioDecoderCapabilitiesItf self, XAuint32* pNumDecoders,
       
    54         XAuint32* pDecoderIds)
       
    55     {
       
    56     XAAudioDecoderCapabilitiesItfImpl* impl = GetImpl(self);
       
    57     XAresult res = XA_RESULT_SUCCESS;
       
    58 
       
    59     DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders");
       
    60 
       
    61     if (!impl || !pNumDecoders)
       
    62         {
       
    63         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
       
    64         res = XA_RESULT_PARAMETER_INVALID;
       
    65         }
       
    66     else
       
    67         {
       
    68         if (pDecoderIds)
       
    69             { /* query array of decoders */
       
    70             if (*pNumDecoders < impl->numCodecs)
       
    71                 {
       
    72                 DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");
       
    73                 res = XA_RESULT_BUFFER_INSUFFICIENT;
       
    74                 }
       
    75             else
       
    76                 {
       
    77 
       
    78                 XAuint32 i = 0;
       
    79                 XACapabilities temp;
       
    80                 for (i = 0; i < impl->numCodecs; i++)
       
    81                     {
       
    82                     /* query decoder id from adaptation using index value */
       
    83                     XACapabilitiesMgr_GetCapsByIdx(NULL,
       
    84                             (XACapsType) (XACAP_DECODER | XACAP_AUDIO), i,
       
    85                             &temp);
       
    86                     pDecoderIds[i] = temp.xaid;
       
    87                     }
       
    88 
       
    89                 }
       
    90             }
       
    91         /* return number of decoders */
       
    92         *pNumDecoders = impl->numCodecs;
       
    93         }DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders");
       
    94     return res;
       
    95     }
       
    96 
       
    97 /* XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities
       
    98  * Description: Queries for the audio decoder�s capabilities.
       
    99  */
       
   100 XAresult XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities(
       
   101         XAAudioDecoderCapabilitiesItf self, XAuint32 decoderId,
       
   102         XAuint32* pIndex, XAAudioCodecDescriptor* pDescriptor)
       
   103     {
       
   104     XAAudioDecoderCapabilitiesItfImpl* impl = GetImpl(self);
       
   105     XAresult res = XA_RESULT_SUCCESS;
       
   106 
       
   107     DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities");
       
   108 
       
   109     if (!impl || !pIndex)
       
   110         {
       
   111         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
       
   112         res = XA_RESULT_PARAMETER_INVALID;
       
   113         }
       
   114     else
       
   115         {
       
   116         if (!pDescriptor)
       
   117             { /* query number of capa structures */
       
   118             *pIndex = 1;
       
   119             }
       
   120         else
       
   121             { /* query capabilities */
       
   122             if (*pIndex >= 1)
       
   123                 {
       
   124                 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
       
   125                 res = XA_RESULT_PARAMETER_INVALID;
       
   126                 }
       
   127             else
       
   128                 {
       
   129 
       
   130                 /* query capabilities from adaptation using codec id */
       
   131                 XACapabilities temp;
       
   132                 memset(pDescriptor, 0, sizeof(XAAudioCodecDescriptor));
       
   133                 res = XACapabilitiesMgr_GetCapsById(NULL,
       
   134                         (XACapsType) (XACAP_DECODER | XACAP_AUDIO),
       
   135                         decoderId, &temp);
       
   136                 if (res == XA_RESULT_SUCCESS)
       
   137                     {
       
   138                     XAAudioCodecDescriptor* desc =
       
   139                             ((XAAudioCodecDescriptor*) (temp.pEntry));
       
   140                     /* map applicable values to XAAudioCodecCapabilities */
       
   141                     pDescriptor->maxChannels = desc->maxChannels;
       
   142                     pDescriptor->minSampleRate = desc->minSampleRate; /* milliHz */
       
   143                     if (desc->maxSampleRate < (0xFFFFFFFF))
       
   144                         {
       
   145                         pDescriptor->maxSampleRate = desc->maxSampleRate;
       
   146                         }
       
   147                     else
       
   148                         {
       
   149                         pDescriptor->maxSampleRate = 0xFFFFFFFF;
       
   150                         }
       
   151                     pDescriptor->minBitsPerSample = desc->minBitsPerSample;
       
   152                     pDescriptor->maxBitsPerSample = desc->maxBitsPerSample;
       
   153                     pDescriptor->isFreqRangeContinuous=desc->isFreqRangeContinuous;
       
   154                     pDescriptor->minBitRate = desc->minBitRate;
       
   155                     pDescriptor->maxBitRate = desc->maxBitRate;
       
   156                     pDescriptor->numBitratesSupported
       
   157                             = desc->numBitratesSupported;
       
   158                     pDescriptor->isBitrateRangeContinuous=desc->isBitrateRangeContinuous;
       
   159                     pDescriptor->profileSetting=desc->profileSetting;
       
   160                     pDescriptor->modeSetting=desc->modeSetting; /* no chanmode for pcm defined */
       
   161                     
       
   162                     }
       
   163                     else
       
   164                         {
       
   165                         /* do nothing */
       
   166                         }
       
   167                     /*other caps undefined*/
       
   168                     }
       
   169 
       
   170                 }
       
   171             }
       
   172     
       
   173 
       
   174     DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities");
       
   175     return res;
       
   176     }
       
   177 
       
   178 /*****************************************************************************
       
   179  * XAAudioDecoderCapabilitiesItfImpl -specific methods
       
   180  *****************************************************************************/
       
   181 
       
   182 /* XAAudioDecoderCapabilitiesItfImpl_Create
       
   183  * Description: Allocate and initialize XAAudioDecoderCapabilitiesItfImpl
       
   184  */
       
   185 XAAudioDecoderCapabilitiesItfImpl* XAAudioDecoderCapabilitiesItfImpl_Create()
       
   186     {
       
   187     XAAudioDecoderCapabilitiesItfImpl* self =
       
   188             (XAAudioDecoderCapabilitiesItfImpl*) calloc(1,
       
   189                     sizeof(XAAudioDecoderCapabilitiesItfImpl));
       
   190 
       
   191     DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_Create");
       
   192 
       
   193     if (self)
       
   194         {
       
   195         /* init itf default implementation */
       
   196         self->itf.GetAudioDecoders
       
   197                 = XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoders;
       
   198         self->itf.GetAudioDecoderCapabilities
       
   199                 = XAAudioDecoderCapabilitiesItfImpl_GetAudioDecoderCapabilities;
       
   200 
       
   201         /* init variables */
       
   202 
       
   203         assert( XACapabilitiesMgr_GetCapsCount(NULL, (XACapsType)(XACAP_DECODER|XACAP_AUDIO),
       
   204                         &(self->numCodecs) ) == XA_RESULT_SUCCESS );
       
   205 
       
   206         self->self = self;
       
   207         }DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_Create");
       
   208     return self;
       
   209     }
       
   210 
       
   211 /* void XAAudioDecoderCapabilitiesItfImpl_Free
       
   212  * Description: Free all resources reserved at XAAudioDecoderCapabilitiesItfImpl_Create
       
   213  */
       
   214 void XAAudioDecoderCapabilitiesItfImpl_Free(
       
   215         XAAudioDecoderCapabilitiesItfImpl* self)
       
   216     {
       
   217     DEBUG_API("->XAAudioDecoderCapabilitiesItfImpl_Free");
       
   218     assert(self==self->self);
       
   219     free(self);
       
   220     DEBUG_API("<-XAAudioDecoderCapabilitiesItfImpl_Free");
       
   221     }