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 <unistd.h>

    19 #include <gst/gst.h>

    20 #include "xaadaptationgst.h"

    21 #include "xaradioitfadaptation.h"

    22 #include "xaradioadaptctx.h"

    23 

    24 #define NUM_OF_SUPPORTED_RANGES 2

    25 #define NUM_OF_CHANNELS 2

    26 const char* RadioPresetDefaultName = "Default";

    27 

    28 /* emulated frequency range data */

    29 typedef struct FreqRange_

    30 {

    31     XAuint8     id;

    32     XAuint32    minFreq;

    33     XAuint32    maxFreq;

    34     XAuint32    freqInterval;

    35     XAuint32    stereoMode;

    36 } FreqRange;

    37 

    38 /* emulated radio channel data */

    39 typedef struct Channel_

    40 {

    41     XAuint32    freq;

    42     XAuint32    strength;

    43 } Channel;

    44 

    45 /* emulated radio state */

    46 typedef enum

    47 {

    48     RADIO_STATE_ON_CHANNEL,

    49     RADIO_STATE_OFF_CHANNEL

    50 } RadioState;

    51 

    52 /* data structure to pass onto async functions */

    53 typedef struct

    54 {

    55     XAAdaptationGstCtx *bCtx;

    56     XAuint32             value;

    57 } ThreadArgs;

    58 

    59 /* emulation variables and constraints */

    60 static const FreqRange supportedFreqRanges[NUM_OF_SUPPORTED_RANGES] = {

    61         { XA_FREQRANGE_FMEUROAMERICA, 87500000, 108000000, 100000, XA_STEREOMODE_MONO },

    62         {XA_FREQRANGE_FMJAPAN, 76000000, 90000000, 100000, XA_STEREOMODE_STEREO }};

    63 

    64 static const Channel channels[NUM_OF_CHANNELS] = { {88500000, 80},

    65                                     {89300000, 60 }};

    66 

    67 static XAuint8 freqRangeIndex = 0;

    68 static XAboolean squelchMode = XA_BOOLEAN_FALSE;

    69 static XAint32 currentChannel = -1;

    70 static RadioState radioState = RADIO_STATE_OFF_CHANNEL;

    71 

    72 static void* asyncdata = NULL;

    73 

    74 /* FORWARD DECLARATIONS */

    75 void * XARadioItfAdapt_AsyncSetFrequencyRange(void* args);

    76 XAresult XARadioItfAdapt_SyncSetFrequencyRange(XAAdaptationGstCtx *bCtx, XAuint8 range);

    77 void * XARadioItfAdapt_AsyncSetFrequency(void* args);

    78 XAresult XARadioItfAdapt_SyncSetFrequency(XAAdaptationGstCtx *bCtx, XAuint32 freq);

    79 void * XARadioItfAdapt_AsyncSeek(void* args);

    80 

    81 /*

    82  * XAresult XARadioItfAdapt_SetFreqRange(XAAdaptationGstCtx *bCtx, XAuint8 range)

    83  */

    84 XAresult XARadioItfAdapt_SetFreqRange(XAAdaptationGstCtx *bCtx, XAuint8 range)

    85 {

    86     XAresult ret = XA_RESULT_SUCCESS;

    87     XAuint16 index=0;

    88     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;

    89     int pt_ret=0;

    90     DEBUG_API("->XARadioItfAdapt_SetFreqRange");

    91 

    92     if(!bCtx || range < XA_FREQRANGE_FMEUROAMERICA || range > XA_FREQRANGE_AMSW)

    93     {

    94         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    95         DEBUG_API("<-XARadioItfAdapt_SetFreqRange");

    96         return XA_RESULT_PARAMETER_INVALID;

    97     }

    98 

    99     for (index = 0; index < NUM_OF_SUPPORTED_RANGES; index++)

   100     {

   101         if (supportedFreqRanges[index].id == range)

   102         {

   103             if (mCtx->range != range)

   104             {

   105                 if (mCtx->state != XA_RADIO_IDLE)

   106                 {

   107                   //  pthread_cancel(mCtx->emulationThread);

   108                     if (asyncdata)

   109                     {

   110                         free(asyncdata);

   111                         asyncdata = NULL;

   112                     }

   113                     mCtx->state = XA_RADIO_IDLE;

   114                 }

   115                 {

   116                     ThreadArgs* args = (ThreadArgs*)calloc(1, sizeof(ThreadArgs));

   117                     if (!args)

   118                     {

   119                         DEBUG_ERR("Calloc failed")

   120                         DEBUG_API("<-XARadioItfAdapt_SetFreqRange");

   121                         return XA_RESULT_INTERNAL_ERROR;

   122                     }

   123                     args->bCtx = bCtx;

   124                     args->value = range;

   125                     mCtx->state = XA_RADIO_SETTING_FREQUENCY_RANGE;

   126                     pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARadioItfAdapt_AsyncSetFrequencyRange),(void*)args);

   127 

   128                     if(pt_ret)

   129                     {

   130                         DEBUG_ERR_A1("could not create thread!! (%d)",ret)

   131                         DEBUG_API("<-XARadioItfAdapt_SetFreqRange");

   132                         return XA_RESULT_INTERNAL_ERROR;

   133                     }

   134                 }

   135             }

   136             break;

   137         }

   138     }

   139 

   140     DEBUG_API("<-XARadioItfAdapt_SetFreqRange");

   141     return ret;

   142 }

   143 

   144 /*

   145  * void * XARadioItfAdapt_AsyncSetFrequencyRange(void* args)

   146  */

   147 void * XARadioItfAdapt_AsyncSetFrequencyRange(void* args)

   148 {

   149     XAresult ret = XA_RESULT_SUCCESS;

   150     ThreadArgs* tArgs = NULL;

   151     XARadioAdaptationCtx* mCtx = NULL;

   152 

   153     DEBUG_API("->XARadioItfAdapt_AsyncSetFrequencyRange");

   154     asyncdata = args;

   155     tArgs = args;

   156 

   157     mCtx = (XARadioAdaptationCtx*) tArgs->bCtx;

   158 

   159     DEBUG_INFO("Setting frequency async")

   160     usleep(100000); /* 1/10 seconds */

   161 

   162     ret = XARadioItfAdapt_SyncSetFrequencyRange(tArgs->bCtx, tArgs->value);

   163     if (ret != XA_RESULT_SUCCESS)

   164     {

   165         DEBUG_ERR("XARadioItfAdapt_SyncSetFrequencyRange FAILED");

   166     }

   167 

   168     /* Send event to RadioItf */

   169     {

   170         XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED, 0, NULL};

   171         XAAdaptationBase_SendAdaptEvents(&tArgs->bCtx->baseObj, &event );

   172     }

   173     mCtx->state = XA_RADIO_IDLE;

   174 

   175     free(args);

   176     asyncdata = NULL;

   177     DEBUG_API("<-XARadioItfAdapt_AsyncSetFrequencyRange");

   178     pthread_exit(NULL);

   179     return NULL;

   180 }

   181 

   182 /*

   183  * XAresult XARadioItfAdapt_SyncSetFrequencyRange(XAAdaptationGstCtx *bCtx, XAuint8 range)

   184  */

   185 XAresult XARadioItfAdapt_SyncSetFrequencyRange(XAAdaptationGstCtx *bCtx, XAuint8 range)

   186 {

   187     XAresult ret = XA_RESULT_SUCCESS;

   188     XARadioAdaptationCtx* mCtx=NULL;

   189     XAuint8 index=0;

   190     DEBUG_API("->XARadioItfAdapt_SyncSetFrequencyRange");

   191     if(!bCtx)

   192     {

   193         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   194         DEBUG_API("<-XARadioItfAdapt_SyncSetFrequencyRange");

   195         return XA_RESULT_PARAMETER_INVALID;

   196     }

   197 

   198     mCtx = (XARadioAdaptationCtx*) bCtx;

   199 

   200     if (range != mCtx->range)

   201     {

   202         DEBUG_INFO("Frequency range changed!")

   203 

   204         mCtx->range = range;

   205         for(index = 0; index < NUM_OF_SUPPORTED_RANGES; index++)

   206         {

   207             if (supportedFreqRanges[index].id == mCtx->range)

   208             {

   209                 freqRangeIndex = index;

   210             }

   211         }

   212 

   213         ret = XARadioItfAdapt_SyncSetFrequency( bCtx, RADIO_DEFAULT_FREQ );

   214     }

   215 

   216     DEBUG_API("<-XARadioItfAdapt_SyncSetFrequencyRange");

   217     return ret;

   218 }

   219 

   220 /*

   221  * XAresult XARadioItfAdapt_GetFreqRange(XAAdaptationGstCtx *bCtx,

   222  *                                       XAuint8 * pFreqRange)

   223  */

   224 XAresult XARadioItfAdapt_GetFreqRange(XAAdaptationGstCtx *bCtx,

   225                                       XAuint8 * pFreqRange)

   226 {

   227     XAresult ret = XA_RESULT_SUCCESS;

   228     XARadioAdaptationCtx* mCtx=NULL;

   229     DEBUG_API("->XARadioItfAdapt_GetFreqRange");

   230 

   231     if(!bCtx || !pFreqRange)

   232     {

   233         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   234         DEBUG_API("<-XARadioItfAdapt_GetFreqRange");

   235         return XA_RESULT_PARAMETER_INVALID;

   236     }

   237 

   238     mCtx = (XARadioAdaptationCtx*) bCtx;

   239 

   240     *pFreqRange = mCtx->range;

   241 

   242     DEBUG_API("<-XARadioItfAdapt_GetFreqRange");

   243     return ret;

   244 }

   245 

   246 

   247 

   248 /*

   249  *  XAresult XARadioItfAdapt_IsFreqRangeSupported(XAAdaptationGstCtx *bCtx,

   250  *                                                XAuint8 range,

   251  *                                                XAboolean * pSupported)

   252  */

   253 XAresult XARadioItfAdapt_IsFreqRangeSupported(XAAdaptationGstCtx *bCtx,

   254                                              XAuint8 range,

   255                                              XAboolean * pSupported)

   256 {

   257     XAresult ret = XA_RESULT_SUCCESS;

   258     XAuint16 index=0;

   259     DEBUG_API("->XARadioItfAdapt_IsFreqRangeSupported");

   260 

   261     if(!bCtx || !pSupported || range < XA_FREQRANGE_FMEUROAMERICA || range > XA_FREQRANGE_AMSW)

   262     {

   263         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   264         DEBUG_API("<-XARadioItfAdapt_IsFreqRangeSupported");

   265         return XA_RESULT_PARAMETER_INVALID;

   266     }

   267 

   268     *pSupported = XA_BOOLEAN_FALSE;

   269     for (index = 0; index < NUM_OF_SUPPORTED_RANGES; index++)

   270     {

   271         if (supportedFreqRanges[index].id == range)

   272         {

   273             *pSupported = XA_BOOLEAN_TRUE;

   274             break;

   275         }

   276     }

   277 

   278     DEBUG_API("<-XARadioItfAdapt_IsFreqRangeSupported");

   279     return ret;

   280 }

   281 

   282 /*

   283  * XAresult XARadioItfAdapt_GetFreqRangeProperties(XAAdaptationGstCtx *bCtx,

   284  *                                                 XAuint8 range,

   285  *                                                 XAuint32 * pMinFreq,

   286  *                                                 XAuint32 * pMaxFreq,

   287  *                                                 XAuint32 * pFreqInterval)

   288  */

   289 XAresult XARadioItfAdapt_GetFreqRangeProperties(XAAdaptationGstCtx *bCtx,

   290                                                XAuint8 range,

   291                                                XAuint32 * pMinFreq,

   292                                                XAuint32 * pMaxFreq,

   293                                                XAuint32 * pFreqInterval)

   294 {

   295     XAresult ret = XA_RESULT_SUCCESS;

   296     

   297     XAuint16 index=0;

   298     DEBUG_API("->XARadioItfAdapt_GetFreqRangeProperties");

   299 

   300     if(!bCtx)

   301     {

   302         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   303         DEBUG_API("<-XARadioItfAdapt_GetFreqRangeProperties");

   304         return XA_RESULT_PARAMETER_INVALID;

   305     }

   306 

   307     for (index = 0; index < NUM_OF_SUPPORTED_RANGES; index++)

   308     {

   309         if (supportedFreqRanges[index].id == range)

   310         {

   311             *pMinFreq = supportedFreqRanges[index].minFreq;

   312             *pMaxFreq = supportedFreqRanges[index].maxFreq;

   313             *pFreqInterval = supportedFreqRanges[index].freqInterval;

   314             break;

   315         }

   316     }

   317 

   318     DEBUG_API("<-XARadioItfAdapt_GetFreqRangeProperties");

   319     return ret;

   320 }

   321 

   322 /*

   323  * XAresult XARadioItfAdapt_SetFrequency(XAAdaptationGstCtx *bCtx, XAuint32 freq)

   324  */

   325 XAresult XARadioItfAdapt_SetFrequency(XAAdaptationGstCtx *bCtx, XAuint32 freq)

   326 {

   327     XAresult ret = XA_RESULT_SUCCESS;

   328     int pt_ret=0;

   329     XARadioAdaptationCtx* mCtx=NULL;

   330     DEBUG_API("->XARadioItfAdapt_SetFrequency");

   331 

   332     if(!bCtx || freq < supportedFreqRanges[freqRangeIndex].minFreq

   333             || freq > supportedFreqRanges[freqRangeIndex].maxFreq

   334             || ((freq - supportedFreqRanges[freqRangeIndex].minFreq)

   335                     % supportedFreqRanges[freqRangeIndex].freqInterval) != 0)

   336     {

   337         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   338         DEBUG_API("<-XARadioItfAdapt_SetFrequency");

   339         return XA_RESULT_PARAMETER_INVALID;

   340     }

   341 

   342     mCtx = (XARadioAdaptationCtx*) bCtx;

   343 

   344     if (freq != mCtx->frequency)

   345     {

   346         if (mCtx->state != XA_RADIO_IDLE)

   347         {

   348            // pthread_cancel(mCtx->emulationThread);

   349             if (asyncdata)

   350             {

   351                 free(asyncdata);

   352                 asyncdata = NULL;

   353             }

   354         }

   355 

   356         {

   357             ThreadArgs* args = (ThreadArgs*)calloc(1, sizeof(ThreadArgs));

   358             if (!args)

   359             {

   360                 DEBUG_ERR("Calloc failed")

   361                 DEBUG_API("<-XARadioItfAdapt_SetFrequency");

   362                 return XA_RESULT_INTERNAL_ERROR;

   363             }

   364             args->bCtx = bCtx;

   365             args->value = freq;

   366             mCtx->state = XA_RADIO_SETTING_FREQUENCY;

   367             pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARadioItfAdapt_AsyncSetFrequency),(void*)args);

   368 

   369             if(pt_ret)

   370             {

   371                 DEBUG_ERR_A1("could not create thread!! (%d)",ret)

   372                 DEBUG_API("<-XARadioItfAdapt_SetFrequency");

   373                 return XA_RESULT_INTERNAL_ERROR;

   374             }

   375         }

   376     } /* else do nothing freq was same */

   377 

   378     DEBUG_API("<-XARadioItfAdapt_SetFrequency");

   379     return ret;

   380 }

   381 

   382 /*

   383  * void * XARadioItfAdapt_AsyncSetFrequency(void* args)

   384  */

   385 void * XARadioItfAdapt_AsyncSetFrequency(void* args)

   386 {

   387     ThreadArgs* tArgs = NULL;

   388     XARadioAdaptationCtx* mCtx = NULL;

   389     asyncdata = args;

   390     tArgs = args;

   391 

   392     mCtx = (XARadioAdaptationCtx*) tArgs->bCtx;

   393     DEBUG_API("->XARadioItfAdapt_AsyncSetFrequency");

   394     DEBUG_INFO("Setting frequency async")

   395     usleep(100000); /* 1/10 seconds */

   396 

   397     XARadioItfAdapt_SyncSetFrequency(tArgs->bCtx, tArgs->value);

   398 

   399     /* Send event to RadioItf */

   400     {

   401         XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_FREQUENCY_CHANGED, 0, NULL };

   402         XAAdaptationBase_SendAdaptEvents(&tArgs->bCtx->baseObj, &event );

   403     }

   404     mCtx->state = XA_RADIO_IDLE;

   405 

   406     free(args);

   407     asyncdata = NULL;

   408     DEBUG_API("<-XARadioItfAdapt_AsyncSetFrequency");

   409     pthread_exit(NULL);

   410     return NULL;

   411 }

   412 

   413 /*

   414  * XAresult XARadioItfAdapt_SyncSetFrequency(XAAdaptationGstCtx *bCtx, XAuint32 freq)

   415  */

   416 XAresult XARadioItfAdapt_SyncSetFrequency(XAAdaptationGstCtx *bCtx, XAuint32 freq)

   417 {

   418     XAresult ret = XA_RESULT_SUCCESS;

   419     XAuint8 index=0;

   420     XAboolean channelFound = XA_BOOLEAN_FALSE;

   421     XARadioAdaptationCtx* mCtx=NULL;

   422 

   423     DEBUG_API("->XARadioItfAdapt_SyncSetFrequency");

   424 

   425     if(!bCtx || freq < supportedFreqRanges[freqRangeIndex].minFreq

   426             || freq > supportedFreqRanges[freqRangeIndex].maxFreq

   427             || ((freq - supportedFreqRanges[freqRangeIndex].minFreq)

   428                     % supportedFreqRanges[freqRangeIndex].freqInterval) != 0)

   429     {

   430         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   431         DEBUG_API("<-XARadioItfAdapt_SyncSetFrequency");

   432         return XA_RESULT_PARAMETER_INVALID;

   433     }

   434 

   435     mCtx = (XARadioAdaptationCtx*) bCtx;

   436 

   437     if (freq != mCtx->frequency)

   438     {

   439         for (index = 0; index < NUM_OF_CHANNELS; index++)

   440         {

   441             if (channels[index].freq == freq)

   442             {

   443                 currentChannel = index;

   444                 channelFound = XA_BOOLEAN_TRUE;

   445                 break;

   446             }

   447         }

   448         if ( channelFound == XA_BOOLEAN_FALSE && radioState == RADIO_STATE_ON_CHANNEL)

   449         {

   450             if (squelchMode == XA_BOOLEAN_FALSE)

   451             {

   452                 DEBUG_API("Channel not found, squelch mode off, set radio to white noise");

   453                 g_object_set( G_OBJECT(bCtx->bin), "wave", GST_AUDIO_TEST_SRC_WAVE_WHITE_NOISE, NULL );

   454             }

   455             else

   456             {

   457                 DEBUG_API("Channel not found, squelch mode off, set radio to silence");

   458                 g_object_set( G_OBJECT(bCtx->bin), "wave", GST_AUDIO_TEST_SRC_WAVE_SILENCE, NULL );

   459             }

   460             radioState = RADIO_STATE_OFF_CHANNEL;

   461         }

   462         else if ( channelFound == XA_BOOLEAN_TRUE && radioState == RADIO_STATE_OFF_CHANNEL )

   463         {

   464             DEBUG_API("Channel found, set radio to sine wave");

   465             g_object_set( G_OBJECT(bCtx->bin), "wave", GST_AUDIO_TEST_SRC_WAVE_SINE, NULL );

   466             radioState = RADIO_STATE_ON_CHANNEL;

   467         }

   468         else

   469         {

   470             /* do nothing */

   471         }

   472 

   473         DEBUG_INFO("Frequency changed!")

   474 

   475         mCtx->frequency = freq;

   476     } /* else frequency not changed do nothing */

   477 

   478     DEBUG_API("<-XARadioItfAdapt_SyncSetFrequency");

   479     return ret;

   480 }

   481 

   482 /*

   483  * XAresult XARadioItfAdapt_GetFrequency(XAAdaptationGstCtx *bCtx,

   484  *                                       XAuint32 * pFrequency)

   485  */

   486 XAresult XARadioItfAdapt_GetFrequency(XAAdaptationGstCtx *bCtx,

   487                                       XAuint32 * pFrequency)

   488 {

   489     XAresult ret = XA_RESULT_SUCCESS;

   490     XARadioAdaptationCtx* mCtx=NULL;

   491     DEBUG_API("->XARadioItfAdapt_GetFrequency");

   492 

   493     if(!bCtx || !pFrequency)

   494     {

   495         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   496         DEBUG_API("<-XARadioItfAdapt_GetFrequency");

   497         return XA_RESULT_PARAMETER_INVALID;

   498     }

   499 

   500     mCtx = (XARadioAdaptationCtx*) bCtx;

   501 

   502     *pFrequency = mCtx->frequency;

   503 

   504     DEBUG_API("<-XARadioItfAdapt_GetFrequency");

   505     return ret;

   506 }

   507 

   508 

   509 /*

   510  * XAresult XARadioItfAdapt_CancelSetFrequency(XAAdaptationGstCtx *bCtx)

   511  */

   512 XAresult XARadioItfAdapt_CancelSetFrequency(XAAdaptationGstCtx *bCtx)

   513 {

   514     XAresult ret = XA_RESULT_SUCCESS;

   515     XARadioAdaptationCtx* mCtx=NULL;

   516     DEBUG_API("->XARadioItfAdapt_CancelSetFrequency");

   517 

   518     if(!bCtx)

   519     {

   520         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   521         DEBUG_API("<-XARadioItfAdapt_CancelSetFrequency");

   522         return XA_RESULT_PARAMETER_INVALID;

   523     }

   524 

   525     mCtx = (XARadioAdaptationCtx*) bCtx;

   526 

   527 

   528     if (mCtx->state == XA_RADIO_SEEKING)

   529     {

   530       //  pthread_cancel(mCtx->emulationThread);

   531         mCtx->state = XA_RADIO_IDLE;

   532     }

   533 

   534     DEBUG_API("<-XARadioItfAdapt_CancelSetFrequency");

   535     return ret;

   536 }

   537 

   538 /*

   539  * XAresult XARadioItfAdapt_SetSquelch(XAAdaptationGstCtx *bCtx, XAboolean squelch)

   540  */

   541 XAresult XARadioItfAdapt_SetSquelch(XAAdaptationGstCtx *bCtx, XAboolean squelch)

   542 {

   543     XAresult ret = XA_RESULT_SUCCESS;

   544     DEBUG_API("->XARadioItfAdapt_SetSquelch");

   545 

   546     if(!bCtx)

   547     {

   548         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   549         DEBUG_API("<-XARadioItfAdapt_SetSquelch");

   550         return XA_RESULT_PARAMETER_INVALID;

   551     }

   552 

   553     if (squelch != squelchMode)

   554     {

   555         if (radioState == RADIO_STATE_OFF_CHANNEL)

   556         {

   557             if (squelch == XA_BOOLEAN_FALSE)

   558             {

   559                 DEBUG_API("Squelch untoggled, no channel, set radio to white noise")

   560                 g_object_set( G_OBJECT(bCtx->bin), "wave", GST_AUDIO_TEST_SRC_WAVE_WHITE_NOISE, NULL );

   561             }

   562             else

   563             {

   564                 DEBUG_API("Squelch toggled, no channel, set radio to silence")

   565                 g_object_set( G_OBJECT(bCtx->bin), "wave", GST_AUDIO_TEST_SRC_WAVE_SILENCE, NULL );

   566             }

   567         }

   568         else

   569         {

   570             DEBUG_API("Squelch toggled, radio on channel, radio not changed")

   571         }

   572         squelchMode = squelch;

   573     } /* else do nothing as mode not changed */

   574 

   575     DEBUG_API("<-XARadioItfAdapt_SetSquelch");

   576     return ret;

   577 }

   578 

   579 /*

   580  * XAresult XARadioItfAdapt_SetStereoMode(XAAdaptationGstCtx *bCtx, XAuint32 mode)

   581  */

   582 XAresult XARadioItfAdapt_SetStereoMode(XAAdaptationGstCtx *bCtx, XAuint32 mode)

   583 {

   584     XAresult ret = XA_RESULT_SUCCESS;

   585     DEBUG_API("->XARadioItfAdapt_SetStereoMode");

   586 

   587     if(!bCtx || mode > XA_STEREOMODE_AUTO )

   588     {

   589         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   590         DEBUG_API("<-XARadioItfAdapt_SetStereoMode");

   591         return XA_RESULT_PARAMETER_INVALID;

   592     }

   593 

   594     switch ( mode )

   595     {

   596         case XA_STEREOMODE_MONO:

   597             /* always works */

   598             break;

   599         case XA_STEREOMODE_STEREO:

   600             if ( supportedFreqRanges[freqRangeIndex].stereoMode == XA_STEREOMODE_MONO )

   601             {

   602                 DEBUG_ERR("StereoMode stereo unsupported");

   603                 ret = XA_RESULT_FEATURE_UNSUPPORTED;

   604             }

   605             break;

   606         case XA_STEREOMODE_AUTO:

   607             if ( supportedFreqRanges[freqRangeIndex].stereoMode != XA_STEREOMODE_AUTO )

   608             {

   609                 DEBUG_ERR("StereoMode auto unsupported");

   610                 ret = XA_RESULT_FEATURE_UNSUPPORTED;

   611             }

   612             break;

   613         default :

   614             DEBUG_ERR("XA_RESULT_INTERNAL_ERROR");

   615             ret = XA_RESULT_INTERNAL_ERROR; /* shouldn't come here */

   616             break;

   617     }

   618 

   619     DEBUG_API("<-XARadioItfAdapt_SetStereoMode");

   620     return ret;

   621 }

   622 

   623 /*

   624  * XAresult XARadioItfAdapt_GetSignalStrength(XAAdaptationGstCtx *bCtx, XAuint32 * pStrength)

   625  */

   626 XAresult XARadioItfAdapt_GetSignalStrength(XAAdaptationGstCtx *bCtx, XAuint32 * pStrength)

   627 {

   628     XAresult ret = XA_RESULT_SUCCESS;

   629     DEBUG_API("->XARadioItfAdapt_GetSignalStrength");

   630 

   631     if(!bCtx || !pStrength)

   632     {

   633         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   634         DEBUG_API("<-XARadioItfAdapt_GetSignalStrength");

   635         return XA_RESULT_PARAMETER_INVALID;

   636     }

   637 

   638     if (currentChannel != -1)

   639     {

   640         *pStrength = channels[currentChannel].strength;

   641     }

   642     else

   643     {

   644         *pStrength = 0;

   645     }

   646 

   647     DEBUG_API("<-XARadioItfAdapt_GetSignalStrength");

   648     return ret;

   649 }

   650 

   651 /*

   652  * XAresult XARadioItfAdapt_Seek(XAAdaptationGstCtx *bCtx, XAboolean upwards)

   653  */

   654 XAresult XARadioItfAdapt_Seek(XAAdaptationGstCtx *bCtx, XAboolean upwards)

   655 {

   656     XAresult ret = XA_RESULT_SUCCESS;

   657     XARadioAdaptationCtx* mCtx = NULL;

   658     int pt_ret=0;

   659     DEBUG_API("->XARadioItfAdapt_Seek");

   660 

   661     if(!bCtx)

   662     {

   663         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   664         DEBUG_API("<-XARadioItfAdapt_Seek");

   665         return XA_RESULT_PARAMETER_INVALID;

   666     }

   667 

   668     mCtx = (XARadioAdaptationCtx*) bCtx;

   669 

   670     if (mCtx->state != XA_RADIO_IDLE)

   671     {

   672        // pthread_cancel(mCtx->emulationThread);

   673         if (asyncdata)

   674         {

   675             free(asyncdata);

   676             asyncdata = NULL;

   677         }

   678         mCtx->state = XA_RADIO_IDLE;

   679     }

   680 

   681     mCtx->state = XA_RADIO_SEEKING;

   682     pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARadioItfAdapt_AsyncSeek),(void*)bCtx);

   683 

   684     if(pt_ret)

   685     {

   686         DEBUG_ERR_A1("could not create thread!! (%d)",ret)

   687         DEBUG_API("<-XARadioItfAdapt_Seek");

   688         return XA_RESULT_INTERNAL_ERROR;

   689     }

   690 

   691     DEBUG_API("<-XARadioItfAdapt_Seek");

   692     return ret;

   693 }

   694 

   695 /*

   696  * void * XARadioItfAdapt_AsyncSeek(void* args)

   697  */

   698 void * XARadioItfAdapt_AsyncSeek(void* args)

   699 {

   700     XAresult ret = XA_RESULT_SUCCESS;

   701 

   702     XAAdaptationGstCtx *bCtx = (XAAdaptationGstCtx*)args;

   703 

   704     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;

   705 

   706     XAuint8 index=0;

   707     XAint8 currentChannel = 0;

   708     XAuint32 freq=0;

   709     mCtx->state = XA_RADIO_SEEKING;

   710     usleep(100000); /* 1/10 seconds */

   711 

   712     DEBUG_INFO("Seek done!")

   713 

   714     for( index = 0; index < NUM_OF_CHANNELS; index++)

   715     {

   716         if (channels[index].freq == mCtx->frequency)

   717         {

   718             currentChannel = index;

   719             break;

   720         }

   721     }

   722 

   723     freq = channels[(currentChannel + 1)%NUM_OF_CHANNELS].freq;

   724 

   725     ret = XARadioItfAdapt_SyncSetFrequency( bCtx, freq );

   726     if (ret != XA_RESULT_SUCCESS)

   727     {

   728         DEBUG_ERR("XARadioItfAdapt_SyncSetFrequency failed")

   729     }

   730 

   731     /* Send event to RadioItf */

   732     {

   733         XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_SEEK_COMPLETE, 0, NULL };

   734         XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event );

   735     }

   736     mCtx->state = XA_RADIO_IDLE;

   737 

   738     pthread_exit(NULL);

   739     return NULL;

   740 }

   741 

   742 /*

   743  * XAresult XARadioItfAdapt_StopSeeking(XAAdaptationGstCtx *bCtx)

   744  */

   745 XAresult XARadioItfAdapt_StopSeeking(XAAdaptationGstCtx *bCtx)

   746 {

   747     XAresult ret = XA_RESULT_SUCCESS;

   748     XARadioAdaptationCtx* mCtx = NULL;

   749     DEBUG_API("->XARadioItfAdapt_StopSeeking");

   750 

   751     if(!bCtx)

   752     {

   753         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   754         DEBUG_API("<-XARadioItfAdapt_StopSeeking");

   755         return XA_RESULT_INTERNAL_ERROR;

   756     }

   757 

   758     mCtx = (XARadioAdaptationCtx*) bCtx;

   759 

   760     if (mCtx->state == XA_RADIO_SEEKING)

   761     {

   762         mCtx->state = XA_RADIO_IDLE;

   763       //  pthread_cancel(mCtx->emulationThread);

   764 

   765         /* just put some random non-channel freq */

   766         ret = XARadioItfAdapt_SyncSetFrequency( bCtx, channels[0].freq+supportedFreqRanges[freqRangeIndex].freqInterval);

   767         if (ret != XA_RESULT_SUCCESS)

   768         {

   769             ret = XA_RESULT_INTERNAL_ERROR;

   770         }

   771     }

   772 

   773     DEBUG_API("<-XARadioItfAdapt_StopSeeking");

   774     return ret;

   775 }

   776 

   777 /*

   778  * void XARadioItfAdapt_Free(XAAdaptationGstCtx *bCtx)

   779  */

   780 void XARadioItfAdapt_Free(XAAdaptationBaseCtx *bCtx)

   781 {

   782     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;

   783     DEBUG_API("->XARadioItfAdapt_Free");

   784 

   785     if (mCtx->state != XA_RADIO_IDLE)

   786     {

   787        // pthread_cancel(mCtx->emulationThread);

   788         if (asyncdata)

   789         {

   790             free(asyncdata);

   791             asyncdata = NULL;

   792         }

   793         mCtx->state = XA_RADIO_IDLE;

   794     }

   795 

   796     DEBUG_API("<-XARadioItfAdapt_Free");

   797 }