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/radio/xaradioitf.c
changeset 21 2ed61feeead6
parent 19 4a629bc82c5e
child 25 6f7ceef7b1d1
equal deleted inserted replaced
20:b67dd1fc57c5 21:2ed61feeead6 
    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 <string.h>
 
    21 #include <string.h>
 
       
    22 #include <xaradioitfext.h>
 
    22 #include "xaradioitf.h"
 
    23 #include "xaradioitf.h"
 
    23 
       
    24 #include "xaradioitfadaptation.h"
 
    24 #include "xaradioitfadaptation.h"
 
    25 
       
    26 #include "xathreadsafety.h"
 
    25 #include "xathreadsafety.h"
 
       
    26 
       
    27 #define FREQINTERVAL 20
 
    27 
    28 
    28 /**
 
    29 /**
 
    29  * XARadioItfImpl* GetImpl(XARadioItf self)
 
    30  * XARadioItfImpl* GetImpl(XARadioItf self)
 
    30  * Description: Validated interface pointer and cast it to implementations pointer.
 
    31  * Description: Validated interface pointer and cast it to implementations pointer.
 
    31  **/
 
    32  **/
 
    52  *              XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED event is used for notifying of the result.
 
    53  *              XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED event is used for notifying of the result.
 
    53  **/
 
    54  **/
 
    54 XAresult XARadioItfImpl_SetFreqRange(XARadioItf self, XAuint8 range)
 
    55 XAresult XARadioItfImpl_SetFreqRange(XARadioItf self, XAuint8 range)
 
    55 {
 
    56 {
 
    56     XAresult ret = XA_RESULT_SUCCESS;
 
    57     XAresult ret = XA_RESULT_SUCCESS;
 
    57 
       
    58     XAboolean isSupported = XA_BOOLEAN_FALSE;
 
    58     XAboolean isSupported = XA_BOOLEAN_FALSE;
 
    59 
       
    60     XARadioItfImpl* impl = GetImpl(self);
 
    59     XARadioItfImpl* impl = GetImpl(self);
 
    61 
    60 
    62     DEBUG_API("->XARadioItfImpl_SetFreqRange");
 
    61     DEBUG_API("->XARadioItfImpl_SetFreqRange");
 
    63     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
 
    62     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
 
    64 
    63 
    70         DEBUG_API("<-XARadioItfImpl_SetFreqRange");
 
    69         DEBUG_API("<-XARadioItfImpl_SetFreqRange");
 
    71 
    70 
    72         return XA_RESULT_PARAMETER_INVALID;
 
    71         return XA_RESULT_PARAMETER_INVALID;
 
    73     }
 
    72     }
 
    74 
    73 
    75 
    74     ret = XARadioItfAdapt_IsFreqRangeSupported(range, &isSupported);
 
    76     ret = XARadioItfAdapt_IsFreqRangeSupported((XAAdaptationGstCtx*)impl->adapCtx, range, &isSupported);
 
       
    77 
    75 
    78     if ( ret == XA_RESULT_SUCCESS && isSupported == XA_BOOLEAN_TRUE )
 
    76     if ( ret == XA_RESULT_SUCCESS && isSupported == XA_BOOLEAN_TRUE )
 
    79     {
 
    77     {
 
    80         ret = XARadioItfAdapt_SetFreqRange((XAAdaptationGstCtx*)impl->adapCtx, range);
 
    78         ret = XARadioItfAdapt_SetFreqRange((XAAdaptationMMFCtx*)impl->adapCtx, range);
 
    81     }
 
    79     }
 
    82 
    80 
    83     
       
    84     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
    81     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
    85     DEBUG_API("<-XARadioItfImpl_SetFreqRange");
 
    82     DEBUG_API("<-XARadioItfImpl_SetFreqRange");
 
    86     return ret;
 
    83     return ret;
 
    87 }
 
    84 }
 
    88 
    85 
   104         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   101         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   105         DEBUG_API("<-XARadioItfImpl_GetFreqRange");
 
   102         DEBUG_API("<-XARadioItfImpl_GetFreqRange");
 
   106         return XA_RESULT_PARAMETER_INVALID;
 
   103         return XA_RESULT_PARAMETER_INVALID;
 
   107     }
 
   104     }
 
   108 
   105 
   109 
   106     ret = XARadioItfAdapt_GetFreqRange(pRange);
 
   110     ret = XARadioItfAdapt_GetFreqRange( (XAAdaptationGstCtx*)impl->adapCtx, pRange);
 
       
   111 
   107 
   112     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   108     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   113     DEBUG_API("<-XARadioItfImpl_GetFreqRange");
 
   109     DEBUG_API("<-XARadioItfImpl_GetFreqRange");
 
   114     return ret;
 
   110     return ret;
 
   115 }
 
   111 }
 
   136         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   132         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   137         DEBUG_API("<-XARadioItfImpl_IsFreqRangeSupported");
 
   133         DEBUG_API("<-XARadioItfImpl_IsFreqRangeSupported");
 
   138         return XA_RESULT_PARAMETER_INVALID;
 
   134         return XA_RESULT_PARAMETER_INVALID;
 
   139     }
 
   135     }
 
   140 
   136 
   141 
   137     ret = XARadioItfAdapt_IsFreqRangeSupported( range, pSupported );
 
   142     ret = XARadioItfAdapt_IsFreqRangeSupported( (XAAdaptationGstCtx*)impl->adapCtx, range, pSupported );
 
       
   143 
   138 
   144     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   139     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   145     DEBUG_API("<-XARadioItfImpl_IsFreqRangeSupported");
 
   140     DEBUG_API("<-XARadioItfImpl_IsFreqRangeSupported");
 
   146     return ret;
 
   141     return ret;
 
   147 }
 
   142 }
 
   163                                                XAuint32 * pFreqInterval)
 
   158                                                XAuint32 * pFreqInterval)
 
   164 {
 
   159 {
 
   165     XAresult ret = XA_RESULT_SUCCESS;
 
   160     XAresult ret = XA_RESULT_SUCCESS;
 
   166     XAboolean isSupported = XA_BOOLEAN_FALSE;
 
   161     XAboolean isSupported = XA_BOOLEAN_FALSE;
 
   167     XARadioItfImpl* impl = GetImpl(self);
 
   162     XARadioItfImpl* impl = GetImpl(self);
 
       
   163 
       
   164    *pFreqInterval = FREQINTERVAL;   
       
   165 		    
   168     DEBUG_API("->XARadioItfImpl_GetFreqRangeProperties");
 
   166     DEBUG_API("->XARadioItfImpl_GetFreqRangeProperties");
 
   169     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
 
   167     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
 
   170 
   168 
   171     if(!impl || !pMinFreq || !pMaxFreq || !pFreqInterval)
 
   169     if(!impl || !pMinFreq || !pMaxFreq || !pFreqInterval)
 
   172     {
 
   170     {
 
   174         /* invalid parameter */
 
   172         /* invalid parameter */
 
   175         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   173         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   176         DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");
 
   174         DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");
 
   177         return XA_RESULT_PARAMETER_INVALID;
 
   175         return XA_RESULT_PARAMETER_INVALID;
 
   178     }
 
   176     }
 
   179 
   177     ret = XARadioItfAdapt_IsFreqRangeSupported( range, &isSupported );
 
   180     ret = XARadioItfAdapt_IsFreqRangeSupported( (XAAdaptationGstCtx*)impl->adapCtx, range, &isSupported );
 
       
   181 
   178 
   182     if (isSupported != XA_BOOLEAN_TRUE || ret != XA_RESULT_SUCCESS)
 
   179     if (isSupported != XA_BOOLEAN_TRUE || ret != XA_RESULT_SUCCESS)
 
   183     {
 
   180     {
 
   184         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   181         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   185         /* invalid parameter */
 
   182         /* invalid parameter */
 
   186         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   183         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   187         DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");
 
   184         DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");
 
   188         return XA_RESULT_PARAMETER_INVALID;
 
   185         return XA_RESULT_PARAMETER_INVALID;
 
   189     }
 
   186     }
 
   190 
   187 		
   191 
   188     ret = XARadioItfAdapt_GetFreqRangeProperties( (XAAdaptationMMFCtx*)impl->adapCtx,
 
   192     ret = XARadioItfAdapt_GetFreqRangeProperties( (XAAdaptationGstCtx*)impl->adapCtx,
 
   189             range, pMinFreq, pMaxFreq );
 
   193             range, pMinFreq, pMaxFreq, pFreqInterval );
 
       
   194 
   190 
   195     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   191     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   196     DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");
 
   192     DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");
 
   197     return ret;
 
   193     return ret;
 
   198 }
 
   194 }
 
   218         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   214         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   219         DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   215         DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   220         return XA_RESULT_PARAMETER_INVALID;
 
   216         return XA_RESULT_PARAMETER_INVALID;
 
   221     }
 
   217     }
 
   222 
   218 
   223 
   219     ret = XARadioItfAdapt_SetFrequency( (XAAdaptationMMFCtx*)impl->adapCtx, freq );
 
   224     ret = XARadioItfAdapt_SetFrequency( (XAAdaptationGstCtx*)impl->adapCtx, freq );
 
       
   225 
   220 
   226     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   221     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   227     DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   222     DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   228     return ret;
 
   223     return ret;
 
   229 }
 
   224 }
 
   249         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   244         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   250         DEBUG_API("<-XARadioItfImpl_CancelSetFrequency");
 
   245         DEBUG_API("<-XARadioItfImpl_CancelSetFrequency");
 
   251         return XA_RESULT_PARAMETER_INVALID;
 
   246         return XA_RESULT_PARAMETER_INVALID;
 
   252     }
 
   247     }
 
   253 
   248 
   254 
   249     ret = XARadioItfAdapt_CancelSetFrequency();
 
   255     ret = XARadioItfAdapt_CancelSetFrequency( (XAAdaptationGstCtx*)impl->adapCtx );
 
       
   256 
   250 
   257     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   251     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   258     DEBUG_API("<-XARadioItfImpl_CancelSetFrequency");
 
   252     DEBUG_API("<-XARadioItfImpl_CancelSetFrequency");
 
   259     return ret;
 
   253     return ret;
 
   260 }
 
   254 }
 
   277         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   271         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   278         DEBUG_API("<-XARadioItfImpl_GetFrequency");
 
   272         DEBUG_API("<-XARadioItfImpl_GetFrequency");
 
   279         return XA_RESULT_PARAMETER_INVALID;
 
   273         return XA_RESULT_PARAMETER_INVALID;
 
   280     }
 
   274     }
 
   281 
   275 
   282 
   276     ret = XARadioItfAdapt_GetFrequency(pFreq);
 
   283     ret = XARadioItfAdapt_GetFrequency( (XAAdaptationGstCtx*)impl->adapCtx, pFreq);
 
       
   284 
   277 
   285     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   278     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   286     DEBUG_API("<-XARadioItfImpl_GetFrequency");
 
   279     DEBUG_API("<-XARadioItfImpl_GetFrequency");
 
   287     return ret;
 
   280     return ret;
 
   288 }
 
   281 }
 
   307         return XA_RESULT_PARAMETER_INVALID;
 
   300         return XA_RESULT_PARAMETER_INVALID;
 
   308     }
 
   301     }
 
   309 
   302 
   310     if (impl->squelch != squelch)
 
   303     if (impl->squelch != squelch)
 
   311     {
 
   304     {
 
   312 
   305         ret = XARadioItfAdapt_SetSquelch( squelch );
 
   313         ret = XARadioItfAdapt_SetSquelch( (XAAdaptationGstCtx*)impl->adapCtx, squelch );
 
       
   314 
       
   315         if ( ret == XA_RESULT_SUCCESS )
 
   306         if ( ret == XA_RESULT_SUCCESS )
 
   316         {
 
   307         {
 
   317             impl->squelch = squelch;
 
   308             impl->squelch = squelch;
 
   318         }
 
   309         }
 
   319     }
 
   310     }
 
   338         /* invalid parameter */
 
   329         /* invalid parameter */
 
   339         DEBUG_API("<-XARadioItfImpl_GetSquelch");
 
   330         DEBUG_API("<-XARadioItfImpl_GetSquelch");
 
   340         return XA_RESULT_PARAMETER_INVALID;
 
   331         return XA_RESULT_PARAMETER_INVALID;
 
   341     }
 
   332     }
 
   342 
   333 
   343     *pSquelch = impl->squelch;
 
   334   	ret = XARadioItfAdapt_GetSquelch( pSquelch );
 
   344 
   335 
   345     DEBUG_API("<-XARadioItfImpl_GetSquelch");
 
   336     DEBUG_API("<-XARadioItfImpl_GetSquelch");
 
   346     return ret;
 
   337     return ret;
 
   347 }
 
   338 }
 
   348 
   339 
   355     XAresult ret = XA_RESULT_SUCCESS;
 
   346     XAresult ret = XA_RESULT_SUCCESS;
 
   356     XARadioItfImpl* impl = GetImpl(self);
 
   347     XARadioItfImpl* impl = GetImpl(self);
 
   357     DEBUG_API("->XARadioItfImpl_SetStereoMode");
 
   348     DEBUG_API("->XARadioItfImpl_SetStereoMode");
 
   358     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
 
   349     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
 
   359 
   350 
   360     if(!impl || mode > XA_STEREOMODE_AUTO )
 
   351     if( !impl || mode > XA_STEREOMODE_AUTO )
 
   361     {
 
   352     {
 
   362         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   353         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   363         /* invalid parameter */
 
   354         /* invalid parameter */
 
   364         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   355         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   365         DEBUG_API("<-XARadioItfImpl_SetStereoMode");
 
   356         DEBUG_API("<-XARadioItfImpl_SetStereoMode");
 
   366         return XA_RESULT_PARAMETER_INVALID;
 
   357         return XA_RESULT_PARAMETER_INVALID;
 
   367     }
 
   358     }
 
   368 
       
   369     if ( impl->stereoMode != mode)
 
   359     if ( impl->stereoMode != mode)
 
   370     {
 
   360     {
 
   371 
   361         ret = XARadioItfAdapt_SetStereoMode( (XAAdaptationMMFCtx*)impl->adapCtx, mode );
 
   372         ret = XARadioItfAdapt_SetStereoMode( (XAAdaptationGstCtx*)impl->adapCtx, mode );
 
   362        	if ( ret == XA_RESULT_SUCCESS )
 
   373 
       
   374         if ( ret == XA_RESULT_SUCCESS )
 
       
   375         {
 
   363         {
 
   376             impl->stereoMode = mode;
 
   364          	  impl->stereoMode = mode;
 
   377         }
 
   365         }
 
   378     }
 
   366     }    
   379 
       
   380     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   367     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   381     DEBUG_API("<-XARadioItfImpl_SetStereoMode");
 
   368     DEBUG_API("<-XARadioItfImpl_SetStereoMode");
 
   382     return ret;
 
   369     return ret;
 
   383 }
 
   370 }
 
   384 
   371 
   398         /* invalid parameter */
 
   385         /* invalid parameter */
 
   399         DEBUG_API("<-XARadioItfImpl_GetStereoMode");
 
   386         DEBUG_API("<-XARadioItfImpl_GetStereoMode");
 
   400         return XA_RESULT_PARAMETER_INVALID;
 
   387         return XA_RESULT_PARAMETER_INVALID;
 
   401     }
 
   388     }
 
   402 
   389 
   403     *pMode = impl->stereoMode;
 
   390     ret = XARadioItfAdapt_GetStereoMode( pMode );
 
   404 
   391 
   405     DEBUG_API("<-XARadioItfImpl_GetStereoMode");
 
   392     DEBUG_API("<-XARadioItfImpl_GetStereoMode");
 
   406     return ret;
 
   393     return ret;
 
   407 }
 
   394 }
 
   408 
   395 
   424         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   411         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   425         DEBUG_API("<-XARadioItfImpl_GetSignalStrength");
 
   412         DEBUG_API("<-XARadioItfImpl_GetSignalStrength");
 
   426         return XA_RESULT_PARAMETER_INVALID;
 
   413         return XA_RESULT_PARAMETER_INVALID;
 
   427     }
 
   414     }
 
   428 
   415 
   429 
   416     ret = XARadioItfAdapt_GetSignalStrength( pStrength );
 
   430     ret = XARadioItfAdapt_GetSignalStrength( (XAAdaptationGstCtx*)impl->adapCtx, pStrength );
 
       
   431 
   417 
   432     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   418     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   433     DEBUG_API("<-XARadioItfImpl_GetSignalStrength");
 
   419     DEBUG_API("<-XARadioItfImpl_GetSignalStrength");
 
   434     return ret;
 
   420     return ret;
 
   435 }
 
   421 }
 
   456         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   442         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   457         DEBUG_API("<-XARadioItfImpl_Seek");
 
   443         DEBUG_API("<-XARadioItfImpl_Seek");
 
   458         return XA_RESULT_PARAMETER_INVALID;
 
   444         return XA_RESULT_PARAMETER_INVALID;
 
   459     }
 
   445     }
 
   460 
   446 
   461 
   447     ret = XARadioItfAdapt_Seek( (XAAdaptationMMFCtx*)impl->adapCtx, upwards );
 
   462     ret = XARadioItfAdapt_Seek( (XAAdaptationGstCtx*)impl->adapCtx, upwards );
 
       
   463 
   448 
   464     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   449     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   465     DEBUG_API("<-XARadioItfImpl_Seek");
 
   450     DEBUG_API("<-XARadioItfImpl_Seek");
 
   466     return ret;
 
   451     return ret;
 
   467 }
 
   452 }
 
   486         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   471         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   487         DEBUG_API("<-XARadioItfImpl_StopSeeking");
 
   472         DEBUG_API("<-XARadioItfImpl_StopSeeking");
 
   488         return XA_RESULT_PARAMETER_INVALID;
 
   473         return XA_RESULT_PARAMETER_INVALID;
 
   489     }
 
   474     }
 
   490 
   475 
   491 
   476     XARadioItfAdapt_StopSeeking( (XAAdaptationMMFCtx*)impl->adapCtx );
 
   492     ret = XARadioItfAdapt_StopSeeking( (XAAdaptationGstCtx*)impl->adapCtx );
 
       
   493 
   477 
   494     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   478     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   495     DEBUG_API("<-XARadioItfImpl_StopSeeking");
 
   479     DEBUG_API("<-XARadioItfImpl_StopSeeking");
 
   496     return ret;
 
       
   497 }
 
       
   498 
       
   499 /**
 
       
   500  * XAresult XARadioItfImpl_GetNumberOfPresets(XARadioItf self, XAuint32 * pNumPresets)
 
       
   501  * Description: Returns the number of preset slots the device has for storing the presets.
 
       
   502  **/
 
       
   503 XAresult XARadioItfImpl_GetNumberOfPresets(XARadioItf self, XAuint32 * pNumPresets)
 
       
   504 {
 
       
   505     XAresult ret = XA_RESULT_SUCCESS;
 
       
   506     XARadioItfImpl* impl = GetImpl(self);
 
       
   507     DEBUG_API("->XARadioItfImpl_GetNumberOfPresets");
 
       
   508 
       
   509     if(!impl || !pNumPresets)
 
       
   510     {
 
       
   511         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
       
   512         /* invalid parameter */
 
       
   513         DEBUG_API("<-XARadioItfImpl_GetNumberOfPresets");
 
       
   514         return XA_RESULT_PARAMETER_INVALID;
 
       
   515     }
 
       
   516 
       
   517     *pNumPresets = impl->numOfPresets;
 
       
   518 
       
   519     DEBUG_API("<-XARadioItfImpl_GetNumberOfPresets");
 
       
   520     return ret;
 
       
   521 }
 
       
   522 
       
   523 /**
 
       
   524  * XAresult XARadioItfImpl_SetPreset(XARadioItf self,
 
       
   525  *                                   XAuint32 preset,
 
       
   526  *                                   XAuint32 freq,
 
       
   527  *                                   XAuint8 range,
 
       
   528  *                                   XAuint32 mode,
 
       
   529  *                                   const XAchar * name)
 
       
   530  * Description: Sets the preset.
 
       
   531  **/
 
       
   532 XAresult XARadioItfImpl_SetPreset(XARadioItf self,
 
       
   533                                   XAuint32 preset,
 
       
   534                                   XAuint32 freq,
 
       
   535                                   XAuint8 range,
 
       
   536                                   XAuint32 mode,
 
       
   537                                   const XAchar * name)
 
       
   538 {
 
       
   539     XAresult ret = XA_RESULT_SUCCESS;
 
       
   540     XAboolean supported = XA_BOOLEAN_FALSE;
 
       
   541     XAuint32 minFreq = 0;
 
       
   542     XAuint32 maxFreq = 0;
 
       
   543     XAuint32 freqInterval = 0;
 
       
   544 
       
   545     XARadioItfImpl* impl = GetImpl(self);
 
       
   546     DEBUG_API("->XARadioItfImpl_SetPreset");
 
       
   547 
       
   548     if(!impl || !name)
 
       
   549     {
 
       
   550         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
       
   551         /* invalid parameter */
 
       
   552         DEBUG_API("<-XARadioItfImpl_SetPreset");
 
       
   553         return XA_RESULT_PARAMETER_INVALID;
 
       
   554     }
 
       
   555     ret = (*self)->IsFreqRangeSupported(self, range, &supported);
 
       
   556     if(supported != XA_BOOLEAN_TRUE || ret != XA_RESULT_SUCCESS)
 
       
   557     {
 
       
   558         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
       
   559         /* invalid range */
 
       
   560         DEBUG_API("<-XARadioItfImpl_SetPreset");
 
       
   561         return XA_RESULT_PARAMETER_INVALID;
 
       
   562     }
 
       
   563     ret = (*self)->GetFreqRangeProperties(self, range, &minFreq, &maxFreq, &freqInterval);
 
       
   564     if (freq < minFreq || freq > maxFreq || ((freq-minFreq)%freqInterval != 0) ||
 
       
   565             ret != XA_RESULT_SUCCESS)
 
       
   566     {
 
       
   567         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
       
   568         /* invalid freq */
 
       
   569         DEBUG_API("<-XARadioItfImpl_SetPreset");
 
       
   570         return XA_RESULT_PARAMETER_INVALID;
 
       
   571     }
 
       
   572     if (preset < 1 || preset >= impl->numOfPresets ||
 
       
   573              mode > XA_STEREOMODE_AUTO ||
 
       
   574             strlen((char*)name) > RADIO_PRESET_NAME_MAX_LENGTH)
 
       
   575     {
 
       
   576         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
       
   577         /* invalid preset, name or mode*/
 
       
   578         DEBUG_API("<-XARadioItfImpl_SetPreset");
 
       
   579         return XA_RESULT_PARAMETER_INVALID;
 
       
   580     }
 
       
   581 
       
   582 
       
   583     
       
   584     free(impl->presets[preset].name);
 
       
   585 
       
   586     impl->presets[preset].freq = freq;
 
       
   587     impl->presets[preset].range = range;
 
       
   588     impl->presets[preset].stereoMode = mode;
 
       
   589     impl->presets[preset].name = calloc(1, RADIO_PRESET_NAME_MAX_LENGTH+1);
 
       
   590     strncpy( impl->presets[preset].name, (char*)name, RADIO_PRESET_NAME_MAX_LENGTH );
 
       
   591 
       
   592     DEBUG_API("<-XARadioItfImpl_SetPreset");
 
       
   593     return ret;
 
       
   594 }
 
       
   595 
       
   596 /**
 
       
   597  * XAresult XARadioItfImpl_GetPreset(XARadioItf self,
 
       
   598  *                                   XAuint32 preset,
 
       
   599  *                                   XAuint32 * pFreq,
 
       
   600  *                                   XAuint8 * pRange,
 
       
   601  *                                   XAuint32 * pMode,
 
       
   602  *                                   XAchar * pName,
 
       
   603  *                                   XAuint16 * pNameLength)
 
       
   604  * Description: Gets the settings stored into a preset.
 
       
   605  **/
 
       
   606 XAresult XARadioItfImpl_GetPreset(XARadioItf self,
 
       
   607                                   XAuint32 preset,
 
       
   608                                   XAuint32 * pFreq,
 
       
   609                                   XAuint8 * pRange,
 
       
   610                                   XAuint32 * pMode,
 
       
   611                                   XAchar * pName,
 
       
   612                                   XAuint16 * pNameLength)
 
       
   613 {
 
       
   614     /* Supporting CT tester the API signature is newer, but API functionality reflects required spec version.
 
       
   615        Implement newer specification in terms of handling pName and pNameLength*/
 
       
   616     XAresult ret = XA_RESULT_SUCCESS;
 
       
   617     XARadioItfImpl* impl = GetImpl(self);
 
       
   618     DEBUG_API("->XARadioItfImpl_GetPreset");
 
       
   619 
       
   620     if(!impl || !pFreq || !pRange || !pMode || !pNameLength)
 
       
   621     {
 
       
   622         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
       
   623         /* invalid parameter */
 
       
   624         DEBUG_API("<-XARadioItfImpl_GetPreset");
 
       
   625         return XA_RESULT_PARAMETER_INVALID;
 
       
   626     }
 
       
   627     if (pName)
 
       
   628     {
 
       
   629         if(preset < 1 || preset > impl->numOfPresets)
 
       
   630         {
 
       
   631             DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
       
   632             /* invalid parameter */
 
       
   633             DEBUG_API("<-XARadioItfImpl_GetPreset");
 
       
   634             return XA_RESULT_PARAMETER_INVALID;
 
       
   635         }
 
       
   636 
       
   637         *pFreq = impl->presets[preset].freq;
 
       
   638         *pRange = impl->presets[preset].range;
 
       
   639         *pMode = impl->presets[preset].stereoMode;
 
       
   640         if(*pNameLength<RADIO_PRESET_NAME_MAX_LENGTH)
 
       
   641         {
 
       
   642             strncpy( (char*)pName, impl->presets[preset].name, *pNameLength );
 
       
   643             ret = XA_RESULT_BUFFER_INSUFFICIENT;
 
       
   644         }
 
       
   645         else
 
       
   646         {
 
       
   647             strncpy( (char*)pName, impl->presets[preset].name, RADIO_PRESET_NAME_MAX_LENGTH );
 
       
   648         }
 
       
   649         
       
   650     }
 
       
   651     /*Just adding some meaninful value, when supporting new spec this must be fetch the system*/
 
       
   652     *pNameLength = RADIO_PRESET_NAME_MAX_LENGTH;
 
       
   653 
       
   654     DEBUG_API("<-XARadioItfImpl_GetPreset");
 
       
   655     return ret;
 
   480     return ret;
 
   656 }
 
   481 }
 
   657 
   482 
   658 /**
 
   483 /**
 
   659  * XAresult XARadioItfImpl_RegisterRadioCallback(XARadioItf self,
 
   484  * XAresult XARadioItfImpl_RegisterRadioCallback(XARadioItf self,
 
   693  * XARadioItfImplImpl* XARadioItfImpl_Create()
 
   518  * XARadioItfImplImpl* XARadioItfImpl_Create()
 
   694  * Description: Allocate and initialize RadioItfImpl
 
   519  * Description: Allocate and initialize RadioItfImpl
 
   695  **/
 
   520  **/
 
   696 XARadioItfImpl* XARadioItfImpl_Create(XAAdaptationBaseCtx *adapCtx)
 
   521 XARadioItfImpl* XARadioItfImpl_Create(XAAdaptationBaseCtx *adapCtx)
 
   697 {
 
   522 {
 
   698     XAuint16 index = 0;
 
       
   699 
   523 
   700     XARadioItfImpl *self = (XARadioItfImpl*)
 
   524     XARadioItfImpl *self = (XARadioItfImpl*)
 
   701         calloc(1,sizeof(XARadioItfImpl));
 
   525         calloc(1,sizeof(XARadioItfImpl));
 
   702 
   526 
   703     DEBUG_API("->XARadioItfImpl_Create");
 
   527     DEBUG_API("->XARadioItfImpl_Create");
 
   717         self->itf.SetStereoMode = XARadioItfImpl_SetStereoMode;
 
   541         self->itf.SetStereoMode = XARadioItfImpl_SetStereoMode;
 
   718         self->itf.GetStereoMode = XARadioItfImpl_GetStereoMode;
 
   542         self->itf.GetStereoMode = XARadioItfImpl_GetStereoMode;
 
   719         self->itf.GetSignalStrength = XARadioItfImpl_GetSignalStrength;
 
   543         self->itf.GetSignalStrength = XARadioItfImpl_GetSignalStrength;
 
   720         self->itf.Seek = XARadioItfImpl_Seek;
 
   544         self->itf.Seek = XARadioItfImpl_Seek;
 
   721         self->itf.StopSeeking = XARadioItfImpl_StopSeeking;
 
   545         self->itf.StopSeeking = XARadioItfImpl_StopSeeking;
 
   722         self->itf.GetNumberOfPresets = XARadioItfImpl_GetNumberOfPresets;
 
       
   723         self->itf.SetPreset = XARadioItfImpl_SetPreset;
 
       
   724         self->itf.GetPreset = XARadioItfImpl_GetPreset;
 
       
   725         self->itf.RegisterRadioCallback = XARadioItfImpl_RegisterRadioCallback;
 
   546         self->itf.RegisterRadioCallback = XARadioItfImpl_RegisterRadioCallback;
 
   726 
   547 
   727         /* init variables */
 
   548         /* init variables */
 
   728 
   549 
   729         self->squelch = XA_BOOLEAN_FALSE;
 
   550         self->squelch = XA_BOOLEAN_FALSE;
 
   730         self->stereoMode = RADIO_DEFAULT_STEREO_MODE;
 
   551         self->stereoMode = RADIO_DEFAULT_STEREO_MODE;
 
   731 
       
   732         self->preset = 0;
 
       
   733         self->numOfPresets = RADIO_NUM_OF_PRESETS;
 
       
   734 
       
   735         for (index = 0; index < self->numOfPresets; index++)
 
       
   736         {
 
       
   737             self->presets[index].freq = RADIO_DEFAULT_FREQ;
 
       
   738             self->presets[index].range = RADIO_DEFAULT_FREQ_RANGE;
 
       
   739             self->presets[index].stereoMode = RADIO_DEFAULT_STEREO_MODE;
 
       
   740             self->presets[index].name = calloc(1, RADIO_PRESET_NAME_MAX_LENGTH+1);
 
       
   741             strncpy( self->presets[index].name, RadioPresetDefaultName, RADIO_PRESET_NAME_MAX_LENGTH );
 
       
   742         }
 
       
   743 
       
   744         self->callback = NULL;
 
   552         self->callback = NULL;
 
   745         self->context = NULL;
 
   553         self->context = NULL;
 
   746         self->cbPtrToSelf = NULL;
 
   554         self->cbPtrToSelf = NULL;
 
   747 
       
   748         self->adapCtx = adapCtx;
 
   555         self->adapCtx = adapCtx;
 
   749 
   556 
   750         XAAdaptationBase_AddEventHandler( adapCtx, &XARadioItfImpl_AdaptCb, XA_RADIOITFEVENTS, self );
 
   557         XAAdaptationBase_AddEventHandler( adapCtx, &XARadioItfImpl_AdaptCb, XA_RADIOITFEVENTS, self );
 
   751 
   558 
   752         self->self = self;
 
   559         self->self = self;
 
   760  * void XARadioItfImpl_Free(XARadioItfImpl* self)
 
   567  * void XARadioItfImpl_Free(XARadioItfImpl* self)
 
   761  * Description: Free all resources reserved at XARadioItfImpl_Create
 
   568  * Description: Free all resources reserved at XARadioItfImpl_Create
 
   762  **/
 
   569  **/
 
   763 void XARadioItfImpl_Free(XARadioItfImpl* self)
 
   570 void XARadioItfImpl_Free(XARadioItfImpl* self)
 
   764 {
 
   571 {
 
   765     XAuint16 index = 0;
 
       
   766     DEBUG_API("->XARadioItfImpl_Free");
 
   572     DEBUG_API("->XARadioItfImpl_Free");
 
   767     XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS(XATSRadio);
 
   573     XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS(XATSRadio);
 
   768 
       
   769     
       
   770     XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XARadioItfImpl_AdaptCb );
 
   574     XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XARadioItfImpl_AdaptCb );
 
   771 
   575 
   772     XARadioItfAdapt_Free(self->adapCtx);
 
   576     XARadioItfAdapt_Free();
 
   773 
       
   774     for (index = 0; index < self->numOfPresets; index++)
 
       
   775     {
 
       
   776         free(self->presets[index].name);
 
       
   777     }
 
       
   778 
       
   779     assert(self==self->self);
 
   577     assert(self==self->self);
 
   780     free(self);
 
   578     free(self);
 
   781 
   579 
   782     XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS(XATSRadio);
 
   580     XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS(XATSRadio);
 
   783     DEBUG_API("<-XARadioItfImpl_Free");
 
   581     DEBUG_API("<-XARadioItfImpl_Free");
 
   787  * Description: Event handler for adaptation events
 
   585  * Description: Event handler for adaptation events
 
   788  */
 
   586  */
 
   789 void XARadioItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
 
   587 void XARadioItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
 
   790 {
 
   588 {
 
   791     XARadioItfImpl* impl =(XARadioItfImpl*)pHandlerCtx;
 
   589     XARadioItfImpl* impl =(XARadioItfImpl*)pHandlerCtx;
 
       
   590     XAuint32 eventData = 0;
 
       
   591     XAboolean eventBoolean = XA_BOOLEAN_FALSE;
 
       
   592     
   792     DEBUG_API("->XARadioItfimpl_AdaptCb");
 
   593     DEBUG_API("->XARadioItfimpl_AdaptCb");
 
   793 
   594 
   794     if(!impl)
 
   595     if(!impl)
 
   795     {
 
   596     {
 
   796         DEBUG_ERR("XARadioItfImpl_AdaptCb, invalid context pointer!");
 
   597         DEBUG_ERR("XARadioItfImpl_AdaptCb, invalid context pointer!");
 
   799     }
 
   600     }
 
   800     assert(event);
 
   601     assert(event);
 
   801 
   602 
   802     if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_CHANGED && impl->callback )
 
   603     if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_CHANGED && impl->callback )
 
   803     {
 
   604     {
 
   804         DEBUG_API("Frequency changed in adaptation");
 
   605         DEBUG_API("Frequency changed in adaptation"); 
   805         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_CHANGED, 0, XA_BOOLEAN_FALSE );
 
   606         eventData = *(XAuint32*)event->data;
 
   806     }
 
   607         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_CHANGED, eventData, eventBoolean );
 
       
   608     }
 
       
   609     
   807     else if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED && impl->callback )
 
   610     else if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED && impl->callback )
 
   808     {
 
   611     {
 
   809         DEBUG_API("Frequency range changed in adaptation");
 
   612         DEBUG_API("Frequency range changed in adaptation");
 
   810         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED, 0, XA_BOOLEAN_FALSE  );
 
   613 
   811     }
 
   614         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED, eventData, eventBoolean  );
 
       
   615     }
 
       
   616     
   812     else if( event->eventid == XA_ADAPT_RADIO_SEEK_COMPLETE && impl->callback )
 
   617     else if( event->eventid == XA_ADAPT_RADIO_SEEK_COMPLETE && impl->callback )
 
   813     {
 
   618     {
 
   814         DEBUG_API("Seek complete in adaptation");
 
   619         DEBUG_API("Seek complete in adaptation");
 
   815         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SEEK_COMPLETED, 0, XA_BOOLEAN_FALSE  );
 
   620        	eventBoolean = *(XAboolean*)event->data;        
   816     }
 
   621         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SEEK_COMPLETED, eventData, eventBoolean  );     
       
   622     }
 
       
   623     
       
   624     else if( event->eventid == XA_ADAPT_RADIO_STEREO_STATUS_CHANGED && impl->callback )
 
       
   625     {
 
       
   626         DEBUG_API("Stereo status change in adaptation");
 
       
   627       	eventBoolean = *(XAboolean*)event->data;          
       
   628         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_STEREO_STATUS_CHANGED, eventData, eventBoolean  );
 
       
   629     } 
       
   630         
       
   631     else if( event->eventid == XA_ADAPT_RADIO_SIGNAL_STRENGTH_CHANGED && impl->callback )
 
       
   632     {
 
       
   633         DEBUG_API("Signal Strength Change in adaptation");
 
       
   634         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SIGNAL_STRENGTH_CHANGED, eventData, eventBoolean  );
 
       
   635     }      
   817     else
 
   636     else
 
   818     {
 
   637     {
 
   819         /* do nothing */
 
   638         /* do nothing */
 
   820     }
 
   639     }
 
   821     DEBUG_API("<-XARadioItfimpl_AdaptCb");
 
   640     DEBUG_API("<-XARadioItfimpl_AdaptCb");
 
   822 }
 
   641 }
 
   823 
   642 
   824
FCL/sf/mw/mmmw