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/common/xaequalizeritf.c
changeset 16 43d09473c595
parent 12 5a06f39ad45b
equal deleted inserted replaced
14:80975da52420 16:43d09473c595 
    17 
    17 
    18 #include <stdio.h>
 
    18 #include <stdio.h>
 
    19 #include <stdlib.h>
 
    19 #include <stdlib.h>
 
    20 #include <assert.h>
 
    20 #include <assert.h>
 
    21 #include "xaequalizeritf.h"
 
    21 #include "xaequalizeritf.h"
 
    22 #ifdef _GSTREAMER_BACKEND_  
    22 
    23 #include "XAEqualizerItfAdaptation.h"
 
    23 #include "xaequalizeritfadaptation.h"
 
    24 #endif
 
    24 
    25 static const XAuint16 equalizerNumOfPresets = 0;
 
    25 static const XAuint16 equalizerNumOfPresets = 0;
 
    26 
    26 
    27 /**
 
    27 /**
 
    28  * XAEqualizerItfImpl* GetImpl(XAEqualizerItf self)
 
    28  * XAEqualizerItfImpl* GetImpl(XAEqualizerItf self)
 
    29  * Description: Validated interface pointer and cast it to implementations pointer.
 
    29  * Description: Validated interface pointer and cast it to implementations pointer.
 
    51  **/
 
    51  **/
 
    52 XAresult XAEqualizerItfImpl_SetEnabled(XAEqualizerItf self,XAboolean enabled)
 
    52 XAresult XAEqualizerItfImpl_SetEnabled(XAEqualizerItf self,XAboolean enabled)
 
    53 {
 
    53 {
 
    54     XAresult ret = XA_RESULT_SUCCESS;
 
    54     XAresult ret = XA_RESULT_SUCCESS;
 
    55     XAEqualizerItfImpl* impl = GetImpl(self);
 
    55     XAEqualizerItfImpl* impl = GetImpl(self);
 
    56     
    56     XAuint16 index = 0;
 
    57     DEBUG_API("->XAEqualizerItfImpl_SetEnabled");
 
    57     DEBUG_API("->XAEqualizerItfImpl_SetEnabled");
 
    58 
    58 
    59     if(!impl)
 
    59     if(!impl)
 
    60     {
 
    60     {
 
    61         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
    61         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
    62         DEBUG_API("<-XAEqualizerItfImpl_SetEnabled");
 
    62         DEBUG_API("<-XAEqualizerItfImpl_SetEnabled");
 
    63         /* invalid parameter */
 
    63         /* invalid parameter */
 
    64         return XA_RESULT_PARAMETER_INVALID;
 
    64         return XA_RESULT_PARAMETER_INVALID;
 
    65     }
 
    65     }
 
    66 #ifdef _GSTREAMER_BACKEND_
 
    66 
    67     XAuint16 index = 0;
 
    67 
    68     if(enabled && !(impl->enabled))
 
    68     if(enabled && !(impl->enabled))
 
    69     {
 
    69     {
 
    70         for(index = 0; index < EQUALIZER_NUM_OF_BANDS; index++)
 
    70         for(index = 0; index < EQUALIZER_NUM_OF_BANDS; index++)
 
    71         {
 
    71         {
 
    72             if(impl->changeLevel[index])
 
    72             if(impl->changeLevel[index])
 
    73             {
 
    73             {
 
    74                 ret = XAEqualizerItfAdapt_SetBandLevel(impl->adapCtx, index, impl->levels[index]);
 
    74                 ret = XAEqualizerItfAdapt_SetBandLevel((XAAdaptationGstCtx*)impl->adapCtx, index, impl->levels[index]);
 
    75 
    75 
    76                 if(XA_RESULT_SUCCESS == ret)
 
    76                 if(XA_RESULT_SUCCESS == ret)
 
    77                 {
 
    77                 {
 
    78                     impl->changeLevel[index] = XA_BOOLEAN_FALSE;
 
    78                     impl->changeLevel[index] = XA_BOOLEAN_FALSE;
 
    79                 }
 
    79                 }
 
    82     }
 
    82     }
 
    83     else if(!enabled && impl->enabled)
 
    83     else if(!enabled && impl->enabled)
 
    84     {
 
    84     {
 
    85         for(index = 0; index < EQUALIZER_NUM_OF_BANDS; index++)
 
    85         for(index = 0; index < EQUALIZER_NUM_OF_BANDS; index++)
 
    86         {
 
    86         {
 
    87             ret = XAEqualizerItfAdapt_SetBandLevel(impl->adapCtx, index, EQUALIZER_DEFAULT_BAND_LEVEL);
 
    87             ret = XAEqualizerItfAdapt_SetBandLevel((XAAdaptationGstCtx*)impl->adapCtx, index, EQUALIZER_DEFAULT_BAND_LEVEL);
 
    88 
    88 
    89             if(XA_RESULT_SUCCESS == ret)
 
    89             if(XA_RESULT_SUCCESS == ret)
 
    90             {
 
    90             {
 
    91                 impl->changeLevel[index] = XA_BOOLEAN_FALSE;
 
    91                 impl->changeLevel[index] = XA_BOOLEAN_FALSE;
 
    92             }
 
    92             }
 
    94     }
 
    94     }
 
    95     else
 
    95     else
 
    96     {
 
    96     {
 
    97         /* do nothing */
 
    97         /* do nothing */
 
    98     }
 
    98     }
 
    99 #endif
 
    99 
   100     if(ret == XA_RESULT_SUCCESS)
 
   100     if(ret == XA_RESULT_SUCCESS)
 
   101     {
 
   101     {
 
   102         impl->enabled = enabled;
 
   102         impl->enabled = enabled;
 
   103     }
 
   103     }
 
   104 
   104 
   150         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   150         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   151         DEBUG_API("<-XAEqualizerItfImpl_GetNumberOfBands");
 
   151         DEBUG_API("<-XAEqualizerItfImpl_GetNumberOfBands");
 
   152         /* invalid parameter */
 
   152         /* invalid parameter */
 
   153         return XA_RESULT_PARAMETER_INVALID;
 
   153         return XA_RESULT_PARAMETER_INVALID;
 
   154     }
 
   154     }
 
   155 #ifdef _GSTREAMER_BACKEND_  
   155 
   156     *pNumBands = EQUALIZER_NUM_OF_BANDS;
 
   156     *pNumBands = EQUALIZER_NUM_OF_BANDS;
 
   157 #endif
 
   157 
   158     DEBUG_API("<-XAEqualizerItfImpl_GetNumberOfBands");
 
   158     DEBUG_API("<-XAEqualizerItfImpl_GetNumberOfBands");
 
   159     return ret;
 
   159     return ret;
 
   160 }
 
   160 }
 
   161 
   161 
   162 /**
 
   162 /**
 
   178         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   178         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   179         DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
 
   179         DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
 
   180         /* invalid parameter */
 
   180         /* invalid parameter */
 
   181         return XA_RESULT_PARAMETER_INVALID;
 
   181         return XA_RESULT_PARAMETER_INVALID;
 
   182     }
 
   182     }
 
   183 #ifdef _GSTREAMER_BACKEND_  
   183 
   184     ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
 
   184     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);
 
   185     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   185     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   186     {
 
   186     {
 
   187         DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
 
   187         DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
 
   188         return ret;
 
   188         return ret;
 
   189     }
 
   189     }
 
   190     ret = XAEqualizerItfAdapt_GetBandLevelRange(impl->adapCtx, pMin, pMax);
 
   190     ret = XAEqualizerItfAdapt_GetBandLevelRange((XAAdaptationGstCtx*)impl->adapCtx, pMin, pMax);
 
   191     XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
 
   191     XAAdaptationBase_ThreadExit(impl->adapCtx);
 
   192 #endif
 
   192 
   193     DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
 
   193     DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
 
   194     return ret;
 
   194     return ret;
 
   195 }
 
   195 }
 
   196 
   196 
   197 /**
 
   197 /**
 
   234         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   234         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   235         DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
 
   235         DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
 
   236         /* invalid parameter */
 
   236         /* invalid parameter */
 
   237         return XA_RESULT_PARAMETER_INVALID;
 
   237         return XA_RESULT_PARAMETER_INVALID;
 
   238     }
 
   238     }
 
   239 #ifdef _GSTREAMER_BACKEND_  
   239  
   240     ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
 
   240     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);
 
   241     if( ret == XA_RESULT_PARAMETER_INVALID  || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   241     if( ret == XA_RESULT_PARAMETER_INVALID  || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   242     {
 
   242     {
 
   243         DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
 
   243         DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
 
   244         return ret;
 
   244         return ret;
 
   245     }
 
   245     }
 
   246 
   246 
   247     if(impl->enabled)
 
   247     if(impl->enabled)
 
   248     {
 
   248     {
 
   249         ret = XAEqualizerItfAdapt_SetBandLevel(impl->adapCtx, band, level);
 
   249         ret = XAEqualizerItfAdapt_SetBandLevel((XAAdaptationGstCtx*)impl->adapCtx, band, level);
 
   250         if(XA_RESULT_SUCCESS == ret)
 
   250         if(XA_RESULT_SUCCESS == ret)
 
   251         {
 
   251         {
 
   252             impl->levels[band] = level;
 
   252             impl->levels[band] = level;
 
   253         }
 
   253         }
 
   254     }
 
   254     }
 
   256     {
 
   256     {
 
   257         impl->changeLevel[band] = XA_BOOLEAN_TRUE;
 
   257         impl->changeLevel[band] = XA_BOOLEAN_TRUE;
 
   258         impl->levels[band] = level;
 
   258         impl->levels[band] = level;
 
   259     }
 
   259     }
 
   260 
   260 
   261     XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
 
   261     XAAdaptationBase_ThreadExit(impl->adapCtx);
 
   262 #endif    
   262 
   263     DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
 
   263     DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
 
   264     return ret;
 
   264     return ret;
 
   265 }
 
   265 }
 
   266 
   266 
   267 /**
 
   267 /**
 
   271  **/
 
   271  **/
 
   272 XAresult XAEqualizerItfImpl_GetBandLevel(XAEqualizerItf self, XAuint16 band,
 
   272 XAresult XAEqualizerItfImpl_GetBandLevel(XAEqualizerItf self, XAuint16 band,
 
   273                                          XAmillibel *pLevel)
 
   273                                          XAmillibel *pLevel)
 
   274 {
 
   274 {
 
   275     XAresult ret = XA_RESULT_SUCCESS;
 
   275     XAresult ret = XA_RESULT_SUCCESS;
 
       
   276     
       
   277     XAEqualizerItfImpl* impl = GetImpl(self);
 
   276     DEBUG_API("->XAEqualizerItfImpl_GetBandLevel");
 
   278     DEBUG_API("->XAEqualizerItfImpl_GetBandLevel");
 
   277 #ifdef _GSTREAMER_BACKEND_  
   279 
   278     XAEqualizerItfImpl* impl = GetImpl(self);
 
       
   279     if(!impl || !pLevel ||  band >= EQUALIZER_NUM_OF_BANDS)
 
   280     if(!impl || !pLevel ||  band >= EQUALIZER_NUM_OF_BANDS)
 
   280     {
 
   281     {
 
   281         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   282         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   282         DEBUG_API("<-XAEqualizerItfImpl_GetBandLevel");
 
   283         DEBUG_API("<-XAEqualizerItfImpl_GetBandLevel");
 
   283         /* invalid parameter */
 
   284         /* invalid parameter */
 
   284         return XA_RESULT_PARAMETER_INVALID;
 
   285         return XA_RESULT_PARAMETER_INVALID;
 
   285     }
 
   286     }
 
   286 
   287 
   287     *pLevel = impl->levels[band];
 
   288     *pLevel = impl->levels[band];
 
   288 #endif
 
       
   289     DEBUG_API("<-XAEqualizerItfImpl_GetBandLevel");
 
   289     DEBUG_API("<-XAEqualizerItfImpl_GetBandLevel");
 
   290     return ret;
 
   290     return ret;
 
   291 }
 
   291 }
 
   292 
   292 
   293 /**
 
   293 /**
 
   307         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   307         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   308         DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
 
   308         DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
 
   309         /* invalid parameter */
 
   309         /* invalid parameter */
 
   310         return XA_RESULT_PARAMETER_INVALID;
 
   310         return XA_RESULT_PARAMETER_INVALID;
 
   311     }
 
   311     }
 
   312 #ifdef _GSTREAMER_BACKEND_  
   312 
   313     ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
 
   313     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);
 
   314     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   314     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   315     {
 
   315     {
 
   316         DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
 
   316         DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
 
   317         return ret;
 
   317         return ret;
 
   318     }
 
   318     }
 
   319     ret = XAEqualizerItfAdapt_GetCenterFreq(impl->adapCtx, band, pCenter);
 
   319     ret = XAEqualizerItfAdapt_GetCenterFreq((XAAdaptationGstCtx*)impl->adapCtx, band, pCenter);
 
   320 
   320 
   321     XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
 
   321     XAAdaptationBase_ThreadExit(impl->adapCtx);
 
   322 #endif
 
   322 
   323     DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
 
   323     DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
 
   324     return ret;
 
   324     return ret;
 
   325 }
 
   325 }
 
   326 
   326 
   327 /**
 
   327 /**
 
   354         DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
 
   354         DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
 
   355         /* invalid parameter */
 
   355         /* invalid parameter */
 
   356         return XA_RESULT_PARAMETER_INVALID;
 
   356         return XA_RESULT_PARAMETER_INVALID;
 
   357     }
 
   357     }
 
   358 
   358 
   359 #ifdef _GSTREAMER_BACKEND_  
   359  
   360     ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
 
   360     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);
 
   361     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   361     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   362     {
 
   362     {
 
   363         DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
 
   363         DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
 
   364         return ret;
 
   364         return ret;
 
   365     }
 
   365     }
 
   366     ret = XAEqualizerItfAdapt_GetBandFreqRange(impl->adapCtx, band, pMin, pMax);
 
   366     ret = XAEqualizerItfAdapt_GetBandFreqRange((XAAdaptationGstCtx*)impl->adapCtx, band, pMin, pMax);
 
   367 
   367 
   368     XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
 
   368     XAAdaptationBase_ThreadExit(impl->adapCtx);
 
   369 #endif    
   369   
   370     DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
 
   370     DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
 
   371     return ret;
 
   371     return ret;
 
   372 }
 
   372 }
 
   373 
   373 
   374 /**
 
   374 /**
 
   390         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   390         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   391         DEBUG_API("<-XAEqualizerItfImpl_GetBand");
 
   391         DEBUG_API("<-XAEqualizerItfImpl_GetBand");
 
   392         /* invalid parameter */
 
   392         /* invalid parameter */
 
   393         return XA_RESULT_PARAMETER_INVALID;
 
   393         return XA_RESULT_PARAMETER_INVALID;
 
   394     }
 
   394     }
 
   395 #ifdef _GSTREAMER_BACKEND_  
   395   
   396     ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
 
   396     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);
 
   397     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   397     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
 
   398     {
 
   398     {
 
   399         DEBUG_API("<-XAEqualizerItfImpl_GetBand");
 
   399         DEBUG_API("<-XAEqualizerItfImpl_GetBand");
 
   400         return ret;
 
   400         return ret;
 
   401     }
 
   401     }
 
   402     ret = XAEqualizerItfAdapt_GetBand(impl->adapCtx, frequency, pBand);
 
   402     ret = XAEqualizerItfAdapt_GetBand((XAAdaptationGstCtx*)impl->adapCtx, frequency, pBand);
 
   403 
   403 
   404     XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
 
   404     XAAdaptationBase_ThreadExit(impl->adapCtx);
 
   405 #endif
 
   405 
   406     DEBUG_API("<-XAEqualizerItfImpl_GetBand");
 
   406     DEBUG_API("<-XAEqualizerItfImpl_GetBand");
 
   407     return ret;
 
   407     return ret;
 
   408 }
 
   408 }
 
   409 
   409 
   410 /**
 
   410 /**
 
   539 }
 
   539 }
 
   540 
   540 
   541 /**
 
   541 /**
 
   542  * XAEqualizerItfImpl -specific methods
 
   542  * XAEqualizerItfImpl -specific methods
 
   543  **/
 
   543  **/
 
   544 #ifdef _GSTREAMER_BACKEND_  
   544  
   545 
   545 
   546 /**
 
   546 /**
 
   547  * XAEqualizerItfImplImpl* XAEqualizerItfImpl_Create()
 
   547  * XAEqualizerItfImplImpl* XAEqualizerItfImpl_Create()
 
   548  * @return  XAEqualizerItfImplImpl* - Pointer to  EqualizerItf interface implementation
 
   548  * @return  XAEqualizerItfImplImpl* - Pointer to  EqualizerItf interface implementation
 
   549  **/
 
   549  **/
 
   589     }
 
   589     }
 
   590 
   590 
   591     DEBUG_API("<-XAEqualizerItfImpl_Create");
 
   591     DEBUG_API("<-XAEqualizerItfImpl_Create");
 
   592     return self;
 
   592     return self;
 
   593 }
 
   593 }
 
   594 #endif
 
   594 
   595 /**
 
   595 /**
 
   596  * void XAEqualizerItfImpl_Free(XAEqualizerItfImpl* self)
 
   596  * void XAEqualizerItfImpl_Free(XAEqualizerItfImpl* self)
 
   597  * @param  XAEqualizerItfImpl* self -
 
   597  * @param  XAEqualizerItfImpl* self -
 
   598  **/
 
   598  **/
 
   599 void XAEqualizerItfImpl_Free(XAEqualizerItfImpl* self)
 
   599 void XAEqualizerItfImpl_Free(XAEqualizerItfImpl* self)
FCL/sf/mw/mmmw