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: 

    15 *

    16 */

    17 

    18 #include <stdio.h>

    19 #include <stdlib.h>

    20 #include <assert.h>

    21 #include <string.h>

    22 #include "xaradioitf.h"

    23 #ifdef _GSTREAMER_BACKEND_

    24 #include "XARadioItfAdaptation.h"

    25 #endif

    26 #include "xathreadsafety.h"

    27 

    28 /**

    29  * XARadioItfImpl* GetImpl(XARadioItf self)

    30  * Description: Validated interface pointer and cast it to implementations pointer.

    31  **/

    32 static XARadioItfImpl* GetImpl(XARadioItf self)

    33 {

    34     if(self)

    35     {

    36         XARadioItfImpl *impl = (XARadioItfImpl*)(*self);

    37         if(impl && impl == impl->self)

    38         {

    39             return impl;

    40         }

    41     }

    42     return NULL;

    43 }

    44 

    45 /**

    46  * Base interface XARadioItf implementation

    47  */

    48 

    49 /**

    50  * XAresult XARadioItfImpl_SetFreqRange(XARadioItf self, XAuint8 range)

    51  * Description: Sets the frequency range. Asynchronous – xaRadioCallback() callback with

    52  *              XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED event is used for notifying of the result.

    53  **/

    54 XAresult XARadioItfImpl_SetFreqRange(XARadioItf self, XAuint8 range)

    55 {

    56     XAresult ret = XA_RESULT_SUCCESS;

    57 #ifdef _GSTREAMER_BACKEND_

    58     XAboolean isSupported = XA_BOOLEAN_FALSE;

    59 #endif

    60     XARadioItfImpl* impl = GetImpl(self);

    61 

    62     DEBUG_API("->XARadioItfImpl_SetFreqRange");

    63     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

    64 

    65     if(!impl)

    66     {

    67         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

    68         /* invalid parameter */

    69         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    70         DEBUG_API("<-XARadioItfImpl_SetFreqRange");

    71 

    72         return XA_RESULT_PARAMETER_INVALID;

    73     }

    74 

    75 #ifdef _GSTREAMER_BACKEND_

    76     ret = XARadioItfAdapt_IsFreqRangeSupported(impl->adapCtx, range, &isSupported);

    77 

    78     if ( ret == XA_RESULT_SUCCESS && isSupported == XA_BOOLEAN_TRUE )

    79     {

    80         ret = XARadioItfAdapt_SetFreqRange(impl->adapCtx, range);

    81     }

    82 #endif

    83     

    84     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

    85     DEBUG_API("<-XARadioItfImpl_SetFreqRange");

    86     return ret;

    87 }

    88 

    89 /**

    90  * XAresult XARadioItfImpl_GetFreqRange(XARadioItf self, XAuint8 * pRange)

    91  * Description: Gets the current frequency range.

    92  **/

    93 XAresult XARadioItfImpl_GetFreqRange(XARadioItf self, XAuint8 * pRange)

    94 {

    95     XAresult ret = XA_RESULT_SUCCESS;

    96     XARadioItfImpl* impl = GetImpl(self);

    97     DEBUG_API("->XARadioItfImpl_GetFreqRange");

    98     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

    99 

   100     if(!impl || !pRange)

   101     {

   102         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   103         /* invalid parameter */

   104         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   105         DEBUG_API("<-XARadioItfImpl_GetFreqRange");

   106         return XA_RESULT_PARAMETER_INVALID;

   107     }

   108 

   109 #ifdef _GSTREAMER_BACKEND_

   110     ret = XARadioItfAdapt_GetFreqRange( impl->adapCtx, pRange);

   111 #endif

   112     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   113     DEBUG_API("<-XARadioItfImpl_GetFreqRange");

   114     return ret;

   115 }

   116 

   117 /**

   118  * XAresult XARadioItfImpl_IsFreqRangeSupported(XARadioItf self,

   119  *                                              XAuint8 range,

   120  *                                              XAboolean * pSupported)

   121  * Description: Queries if the given frequency range is supported.

   122  **/

   123 XAresult XARadioItfImpl_IsFreqRangeSupported(XARadioItf self,

   124                                              XAuint8 range,

   125                                              XAboolean * pSupported)

   126 {

   127     XAresult ret = XA_RESULT_SUCCESS;

   128     XARadioItfImpl* impl = GetImpl(self);

   129     DEBUG_API("->XARadioItfImpl_IsFreqRangeSupported");

   130     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   131 

   132     if(!impl || !pSupported)

   133     {

   134         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   135         /* invalid parameter */

   136         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   137         DEBUG_API("<-XARadioItfImpl_IsFreqRangeSupported");

   138         return XA_RESULT_PARAMETER_INVALID;

   139     }

   140 

   141 #ifdef _GSTREAMER_BACKEND_

   142     ret = XARadioItfAdapt_IsFreqRangeSupported( impl->adapCtx, range, pSupported );

   143 #endif

   144     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   145     DEBUG_API("<-XARadioItfImpl_IsFreqRangeSupported");

   146     return ret;

   147 }

   148 

   149 

   150 /**

   151  * XAresult XARadioItfImpl_GetFreqRangeProperties(XARadioItf self,

   152  *                                                XAuint8 range,

   153  *                                                XAuint32 * pMinFreq,

   154  *                                                XAuint32 * pMaxFreq,

   155  *                                                XAuint32 * pFreqInterval)

   156  * Description: Returns the minimum and maximum supported frequencies and the

   157  *              modulation of the given frequency range.

   158  **/

   159 XAresult XARadioItfImpl_GetFreqRangeProperties(XARadioItf self,

   160                                                XAuint8 range,

   161                                                XAuint32 * pMinFreq,

   162                                                XAuint32 * pMaxFreq,

   163                                                XAuint32 * pFreqInterval)

   164 {

   165     XAresult ret = XA_RESULT_SUCCESS;

   166     XAboolean isSupported = XA_BOOLEAN_FALSE;

   167     XARadioItfImpl* impl = GetImpl(self);

   168     DEBUG_API("->XARadioItfImpl_GetFreqRangeProperties");

   169     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   170 

   171     if(!impl || !pMinFreq || !pMaxFreq || !pFreqInterval)

   172     {

   173         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   174         /* invalid parameter */

   175         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   176         DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");

   177         return XA_RESULT_PARAMETER_INVALID;

   178     }

   179 #ifdef _GSTREAMER_BACKEND_

   180     ret = XARadioItfAdapt_IsFreqRangeSupported( impl->adapCtx, range, &isSupported );

   181 #endif

   182     if (isSupported != XA_BOOLEAN_TRUE || ret != XA_RESULT_SUCCESS)

   183     {

   184         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   185         /* invalid parameter */

   186         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   187         DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");

   188         return XA_RESULT_PARAMETER_INVALID;

   189     }

   190 

   191 #ifdef _GSTREAMER_BACKEND_

   192     ret = XARadioItfAdapt_GetFreqRangeProperties( impl->adapCtx,

   193             range, pMinFreq, pMaxFreq, pFreqInterval );

   194 #endif

   195     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   196     DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");

   197     return ret;

   198 }

   199 

   200 /**

   201  * XAresult XARadioItfImpl_SetFrequency(XARadioItf self, XAuint32 freq)

   202  * Description: Sets the frequency asynchronously – xaRadioCallback() callback

   203  *              with XA_RADIO_EVENT_FREQUENCY_CHANGED event is used for notifying

   204  *              of the result. The implementation rounds the given value to the

   205  *              nearest supported one. See pFreqInterval parameter of

   206  *              GetFreqRangeProperties() method.

   207  **/

   208 XAresult XARadioItfImpl_SetFrequency(XARadioItf self, XAuint32 freq)

   209 {

   210     XAresult ret = XA_RESULT_SUCCESS;

   211     XARadioItfImpl* impl = GetImpl(self);

   212     DEBUG_API("->XARadioItfImpl_SetFrequency");

   213     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   214 

   215     if(!impl)

   216     {

   217         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   218         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   219         DEBUG_API("<-XARadioItfImpl_SetFrequency");

   220         return XA_RESULT_PARAMETER_INVALID;

   221     }

   222 

   223 #ifdef _GSTREAMER_BACKEND_

   224     ret = XARadioItfAdapt_SetFrequency( impl->adapCtx, freq );

   225 #endif

   226     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   227     DEBUG_API("<-XARadioItfImpl_SetFrequency");

   228     return ret;

   229 }

   230 

   231 /**

   232  * XAresult XARadioItfImpl_CancelSetFrequency(XARadioItf self)

   233  * Description: Cancels an outstanding SetFrequency() request. The method

   234  *              blocks while canceling the outstanding request. Has not effect

   235  *              if no set frequency operation is ongoing.

   236  **/

   237 XAresult XARadioItfImpl_CancelSetFrequency(XARadioItf self)

   238 

   239 {

   240     XAresult ret = XA_RESULT_SUCCESS;

   241     XARadioItfImpl* impl = GetImpl(self);

   242     DEBUG_API("->XARadioItfImpl_CancelSetFrequency");

   243     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   244 

   245     if(!impl)

   246     {

   247         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   248         /* invalid parameter */

   249         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   250         DEBUG_API("<-XARadioItfImpl_CancelSetFrequency");

   251         return XA_RESULT_PARAMETER_INVALID;

   252     }

   253 

   254 #ifdef _GSTREAMER_BACKEND_

   255     ret = XARadioItfAdapt_CancelSetFrequency( impl->adapCtx );

   256 #endif

   257     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   258     DEBUG_API("<-XARadioItfImpl_CancelSetFrequency");

   259     return ret;

   260 }

   261 

   262 /**

   263  * XAresult XARadioItfImpl_GetFrequency(XARadioItf self, XAuint32 * pFreq)

   264  * Description: Gets the current frequency.

   265  **/

   266 XAresult XARadioItfImpl_GetFrequency(XARadioItf self, XAuint32 * pFreq)

   267 {

   268     XAresult ret = XA_RESULT_SUCCESS;

   269     XARadioItfImpl* impl = GetImpl(self);

   270     DEBUG_API("->XARadioItfImpl_GetFrequency");

   271     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   272 

   273     if(!impl || !pFreq)

   274     {

   275         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   276         /* invalid parameter */

   277         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   278         DEBUG_API("<-XARadioItfImpl_GetFrequency");

   279         return XA_RESULT_PARAMETER_INVALID;

   280     }

   281 

   282 #ifdef _GSTREAMER_BACKEND_

   283     ret = XARadioItfAdapt_GetFrequency( impl->adapCtx, pFreq);

   284 #endif

   285     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   286     DEBUG_API("<-XARadioItfImpl_GetFrequency");

   287     return ret;

   288 }

   289 

   290 /**

   291  * XAresult XARadioItfImpl_SetSquelch(XARadioItf self, XAboolean squelch)

   292  * Description: Toggles the squelch (muting in frequencies without broadcast).

   293  **/

   294 XAresult XARadioItfImpl_SetSquelch(XARadioItf self, XAboolean squelch)

   295 {

   296     XAresult ret = XA_RESULT_SUCCESS;

   297     XARadioItfImpl* impl = GetImpl(self);

   298     DEBUG_API("->XARadioItfImpl_SetSquelch");

   299     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   300 

   301     if(!impl)

   302     {

   303         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   304         /* invalid parameter */

   305         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   306         DEBUG_API("<-XARadioItfImpl_SetSquelch");

   307         return XA_RESULT_PARAMETER_INVALID;

   308     }

   309 

   310     if (impl->squelch != squelch)

   311     {

   312 #ifdef _GSTREAMER_BACKEND_

   313         ret = XARadioItfAdapt_SetSquelch( impl->adapCtx, squelch );

   314 #endif

   315         if ( ret == XA_RESULT_SUCCESS )

   316         {

   317             impl->squelch = squelch;

   318         }

   319     }

   320 

   321     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   322     DEBUG_API("<-XARadioItfImpl_SetSquelch");

   323     return ret;

   324 }

   325 

   326 /**

   327  * XAresult XARadioItfImpl_GetSquelch(XARadioItf self, XAboolean * pSquelch)

   328  * Description: Queries the squelch setting (muting in frequencies without broadcast).

   329  **/

   330 XAresult XARadioItfImpl_GetSquelch(XARadioItf self, XAboolean * pSquelch)

   331 {

   332     XAresult ret = XA_RESULT_SUCCESS;

   333     XARadioItfImpl* impl = GetImpl(self);

   334     DEBUG_API("->XARadioItfImpl_GetSquelch");

   335     if(!impl || !pSquelch)

   336     {

   337         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   338         /* invalid parameter */

   339         DEBUG_API("<-XARadioItfImpl_GetSquelch");

   340         return XA_RESULT_PARAMETER_INVALID;

   341     }

   342 

   343     *pSquelch = impl->squelch;

   344 

   345     DEBUG_API("<-XARadioItfImpl_GetSquelch");

   346     return ret;

   347 }

   348 

   349 /**

   350  * XAresult XARadioItfImpl_SetStereoMode(XARadioItf self, XAuint32 mode)

   351  * Description: Sets the current stereo mode.

   352  **/

   353 XAresult XARadioItfImpl_SetStereoMode(XARadioItf self, XAuint32 mode)

   354 {

   355     XAresult ret = XA_RESULT_SUCCESS;

   356     XARadioItfImpl* impl = GetImpl(self);

   357     DEBUG_API("->XARadioItfImpl_SetStereoMode");

   358     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   359 

   360     if(!impl || mode > XA_STEREOMODE_AUTO )

   361     {

   362         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   363         /* invalid parameter */

   364         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   365         DEBUG_API("<-XARadioItfImpl_SetStereoMode");

   366         return XA_RESULT_PARAMETER_INVALID;

   367     }

   368 

   369     if ( impl->stereoMode != mode)

   370     {

   371 #ifdef _GSTREAMER_BACKEND_

   372         ret = XARadioItfAdapt_SetStereoMode( impl->adapCtx, mode );

   373 #endif

   374         if ( ret == XA_RESULT_SUCCESS )

   375         {

   376             impl->stereoMode = mode;

   377         }

   378     }

   379 

   380     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   381     DEBUG_API("<-XARadioItfImpl_SetStereoMode");

   382     return ret;

   383 }

   384 

   385 /**

   386  * XAresult XARadioItfImpl_GetStereoMode(XARadioItf self, XAuint32 * pMode)

   387  * Description: Queries the current stereo mode.

   388  **/

   389 XAresult XARadioItfImpl_GetStereoMode(XARadioItf self, XAuint32 * pMode)

   390 {

   391 

   392     XAresult ret = XA_RESULT_SUCCESS;

   393     XARadioItfImpl* impl = GetImpl(self);

   394     DEBUG_API("->XARadioItfImpl_GetStereoMode");

   395     if(!impl || !pMode)

   396     {

   397         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   398         /* invalid parameter */

   399         DEBUG_API("<-XARadioItfImpl_GetStereoMode");

   400         return XA_RESULT_PARAMETER_INVALID;

   401     }

   402 

   403     *pMode = impl->stereoMode;

   404 

   405     DEBUG_API("<-XARadioItfImpl_GetStereoMode");

   406     return ret;

   407 }

   408 

   409 /**

   410  * XAresult XARadioItfImpl_GetSignalStrength(XARadioItf self, XAuint32 * pStrength)

   411  * Description: Returns the signal strength in per cents.

   412  **/

   413 XAresult XARadioItfImpl_GetSignalStrength(XARadioItf self, XAuint32 * pStrength)

   414 {

   415     XAresult ret = XA_RESULT_SUCCESS;

   416     XARadioItfImpl* impl = GetImpl(self);

   417     DEBUG_API("->XARadioItfImpl_GetSignalStrength");

   418     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   419 

   420     if(!impl || !pStrength)

   421     {

   422         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   423         /* invalid parameter */

   424         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   425         DEBUG_API("<-XARadioItfImpl_GetSignalStrength");

   426         return XA_RESULT_PARAMETER_INVALID;

   427     }

   428 

   429 #ifdef _GSTREAMER_BACKEND_

   430     ret = XARadioItfAdapt_GetSignalStrength( impl->adapCtx, pStrength );

   431 #endif

   432     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   433     DEBUG_API("<-XARadioItfImpl_GetSignalStrength");

   434     return ret;

   435 }

   436 

   437 /**

   438  * XAresult XARadioItfImpl_Seek(XARadioItf self, XAboolean upwards)

   439  * Description: Starts the seek from the current frequency to the given direction.

   440  *              Asynchronous – xaRadioCallback() callback with XA_RADIO_EVENT_SEEK_COMPLETED

   441  *              event is used for notifying of the result. If the end of the tuner’s

   442  *              frequency band is reached before a signal was found, the scan continues

   443  *              from the other end until a signal is found or the original frequency is reached.

   444  **/

   445 XAresult XARadioItfImpl_Seek(XARadioItf self, XAboolean upwards)

   446 {

   447     XAresult ret = XA_RESULT_SUCCESS;

   448     XARadioItfImpl* impl = GetImpl(self);

   449     DEBUG_API("->XARadioItfImpl_Seek");

   450     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   451 

   452     if(!impl)

   453     {

   454         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   455         /* invalid parameter */

   456         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   457         DEBUG_API("<-XARadioItfImpl_Seek");

   458         return XA_RESULT_PARAMETER_INVALID;

   459     }

   460 

   461 #ifdef _GSTREAMER_BACKEND_

   462     ret = XARadioItfAdapt_Seek( impl->adapCtx, upwards );

   463 #endif

   464     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   465     DEBUG_API("<-XARadioItfImpl_Seek");

   466     return ret;

   467 }

   468 

   469 /**

   470  * XAresult XARadioItfImpl_StopSeeking(XARadioItf self)

   471  * Description: Cancels an outstanding seek request. The method blocks while canceling

   472  *              the outstanding request. After cancellation, the frequency is the one

   473  *              where seeking stopped. Has not effect if no seek operation is ongoing.

   474  **/

   475 XAresult XARadioItfImpl_StopSeeking(XARadioItf self)

   476 {

   477     XAresult ret = XA_RESULT_SUCCESS;

   478     XARadioItfImpl* impl = GetImpl(self);

   479     DEBUG_API("->XARadioItfImpl_StopSeeking");

   480     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);

   481 

   482     if(!impl)

   483     {

   484         /* invalid parameter */

   485         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   486         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   487         DEBUG_API("<-XARadioItfImpl_StopSeeking");

   488         return XA_RESULT_PARAMETER_INVALID;

   489     }

   490 

   491 #ifdef _GSTREAMER_BACKEND_

   492     ret = XARadioItfAdapt_StopSeeking( impl->adapCtx );

   493 #endif

   494     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

   495     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 #ifdef _GSTREAMER_BACKEND_

   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 #endif

   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 #ifdef _GSTREAMER_BACKEND_

   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 #endif        

   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;

   656 }

   657 

   658 /**

   659  * XAresult XARadioItfImpl_RegisterRadioCallback(XARadioItf self,

   660  *                                               xaRadioCallback callback,

   661  *                                               void * pContext)

   662  * Description: Sets or clears the xaRadioCallback.

   663  **/

   664 XAresult XARadioItfImpl_RegisterRadioCallback(XARadioItf self,

   665                                               xaRadioCallback callback,

   666                                               void * pContext)

   667 {

   668     XAresult ret = XA_RESULT_SUCCESS;

   669     XARadioItfImpl* impl = GetImpl(self);

   670     DEBUG_API("->XARadioItfImpl_RegisterRadioCallback");

   671 

   672     if(!impl)

   673     {

   674         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   675         /* invalid parameter */

   676         DEBUG_API("<-XARadioItfImpl_RegisterRadioCallback");

   677         return XA_RESULT_PARAMETER_INVALID;

   678     }

   679 

   680     impl->callback = callback;

   681     impl->context = pContext;

   682     impl->cbPtrToSelf = self;

   683 

   684     DEBUG_API("<-XARadioItfImpl_RegisterRadioCallback");

   685     return ret;

   686 }

   687 

   688 /**

   689  * XARadioItfImpl -specific methods

   690  **/

   691 #ifdef _GSTREAMER_BACKEND_

   692 

   693 /**

   694  * XARadioItfImplImpl* XARadioItfImpl_Create()

   695  * Description: Allocate and initialize RadioItfImpl

   696  **/

   697 XARadioItfImpl* XARadioItfImpl_Create(XAAdaptationBaseCtx *adapCtx)

   698 {

   699     XAuint16 index = 0;

   700 

   701     XARadioItfImpl *self = (XARadioItfImpl*)

   702         calloc(1,sizeof(XARadioItfImpl));

   703 

   704     DEBUG_API("->XARadioItfImpl_Create");

   705 

   706     if(self)

   707     {

   708         /* init itf default implementation */

   709         self->itf.SetFreqRange = XARadioItfImpl_SetFreqRange;

   710         self->itf.GetFreqRange = XARadioItfImpl_GetFreqRange;

   711         self->itf.IsFreqRangeSupported = XARadioItfImpl_IsFreqRangeSupported;

   712         self->itf.GetFreqRangeProperties = XARadioItfImpl_GetFreqRangeProperties;

   713         self->itf.SetFrequency = XARadioItfImpl_SetFrequency;

   714         self->itf.CancelSetFrequency = XARadioItfImpl_CancelSetFrequency;

   715         self->itf.GetFrequency = XARadioItfImpl_GetFrequency;

   716         self->itf.SetSquelch = XARadioItfImpl_SetSquelch;

   717         self->itf.GetSquelch = XARadioItfImpl_GetSquelch;

   718         self->itf.SetStereoMode = XARadioItfImpl_SetStereoMode;

   719         self->itf.GetStereoMode = XARadioItfImpl_GetStereoMode;

   720         self->itf.GetSignalStrength = XARadioItfImpl_GetSignalStrength;

   721         self->itf.Seek = XARadioItfImpl_Seek;

   722         self->itf.StopSeeking = XARadioItfImpl_StopSeeking;

   723         self->itf.GetNumberOfPresets = XARadioItfImpl_GetNumberOfPresets;

   724         self->itf.SetPreset = XARadioItfImpl_SetPreset;

   725         self->itf.GetPreset = XARadioItfImpl_GetPreset;

   726         self->itf.RegisterRadioCallback = XARadioItfImpl_RegisterRadioCallback;

   727 

   728         /* init variables */

   729 

   730         self->squelch = XA_BOOLEAN_FALSE;

   731         self->stereoMode = RADIO_DEFAULT_STEREO_MODE;

   732 

   733         self->preset = 0;

   734         self->numOfPresets = RADIO_NUM_OF_PRESETS;

   735 

   736         for (index = 0; index < self->numOfPresets; index++)

   737         {

   738             self->presets[index].freq = RADIO_DEFAULT_FREQ;

   739             self->presets[index].range = RADIO_DEFAULT_FREQ_RANGE;

   740             self->presets[index].stereoMode = RADIO_DEFAULT_STEREO_MODE;

   741             self->presets[index].name = calloc(1, RADIO_PRESET_NAME_MAX_LENGTH+1);

   742             strncpy( self->presets[index].name, RadioPresetDefaultName, RADIO_PRESET_NAME_MAX_LENGTH );

   743         }

   744 

   745         self->callback = NULL;

   746         self->context = NULL;

   747         self->cbPtrToSelf = NULL;

   748 

   749         self->adapCtx = adapCtx;

   750 

   751         XAAdaptationBase_AddEventHandler( adapCtx, &XARadioItfImpl_AdaptCb, XA_RADIOITFEVENTS, self );

   752 

   753         self->self = self;

   754     }

   755 

   756     DEBUG_API("<-XARadioItfImpl_Create");

   757     return self;

   758 }

   759 #endif

   760 /**

   761  * void XARadioItfImpl_Free(XARadioItfImpl* self)

   762  * Description: Free all resources reserved at XARadioItfImpl_Create

   763  **/

   764 void XARadioItfImpl_Free(XARadioItfImpl* self)

   765 {

   766     

   767     DEBUG_API("->XARadioItfImpl_Free");

   768     XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS(XATSRadio);

   769 #ifdef _GSTREAMER_BACKEND_

   770     XAuint16 index = 0;

   771     XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XARadioItfImpl_AdaptCb );

   772 

   773     XARadioItfAdapt_Free(self->adapCtx);

   774 

   775     for (index = 0; index < self->numOfPresets; index++)

   776     {

   777         free(self->presets[index].name);

   778     }

   779 #endif

   780     assert(self==self->self);

   781     free(self);

   782 

   783     XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS(XATSRadio);

   784     DEBUG_API("<-XARadioItfImpl_Free");

   785 }

   786 #ifdef _GSTREAMER_BACKEND_

   787 /* void XARadioItfimpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )

   788  * Description: Event handler for adaptation events

   789  */

   790 void XARadioItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )

   791 {

   792     XARadioItfImpl* impl =(XARadioItfImpl*)pHandlerCtx;

   793     DEBUG_API("->XARadioItfimpl_AdaptCb");

   794 

   795     if(!impl)

   796     {

   797         DEBUG_ERR("XARadioItfImpl_AdaptCb, invalid context pointer!");

   798         DEBUG_API("<-XARadioItfImpl_AdaptCb");

   799         return;

   800     }

   801     assert(event);

   802 

   803     if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_CHANGED && impl->callback )

   804     {

   805         DEBUG_API("Frequency changed in adaptation");

   806         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_CHANGED, 0, XA_BOOLEAN_FALSE );

   807     }

   808     else if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED && impl->callback )

   809     {

   810         DEBUG_API("Frequency range changed in adaptation");

   811         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED, 0, XA_BOOLEAN_FALSE  );

   812     }

   813     else if( event->eventid == XA_ADAPT_RADIO_SEEK_COMPLETE && impl->callback )

   814     {

   815         DEBUG_API("Seek complete in adaptation");

   816         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SEEK_COMPLETED, 0, XA_BOOLEAN_FALSE  );

   817     }

   818     else

   819     {

   820         /* do nothing */

   821     }

   822     DEBUG_API("<-XARadioItfimpl_AdaptCb");

   823 }

   824 #endif

   825