1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     3 *

     4 * This library is free software; you can redistribute it and/or

     5 * modify it under the terms of the GNU Lesser General Public

     6 * License as published by the Free Software Foundation; either

     7 * version 2 of the License, or (at your option) any later version.

     8 *

     9 * This library is distributed in the hope that it will be useful,

    10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12 * Lesser General Public License for more details.

    13 *

    14 * You should have received a copy of the GNU Lesser General Public

    15 * License along with this library; if not, write to the

    16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    17 * Boston, MA 02111-1307, USA.

    18 *

    19 * Description:

    20 *

    21 */

    22 

    23 #include "devsoundsrcwrapper.h"

    24 #include <e32base.h>

    25 #include <mmcccodecinformation.h>

    26 #include "debugtracemacros.h"

    27 

    28 DevSoundWrapperSrc::DevSoundWrapperSrc()

    29     {

    30     init_complete = 0;

    31     dev_sound = NULL;

    32     buffersize = 0;

    33     dev_count = 0;

    34     caps.iRate = EMMFSampleRate8000Hz;

    35     caps.iEncoding = EMMFSoundEncoding16BitPCM;

    36     caps.iChannels = EMMFMono;

    37     fourcc = KMMFFourCCCodePCM16;

    38     iCallbackError = KErrNone;

    39     iSpeechEncoderConfig = NULL;

    40     iG711EncoderIntfc = NULL;

    41     iG729EncoderIntfc = NULL;

    42     iIlbcEncoderIntfc = NULL;

    43     }

    44 

    45 /*********************************************************/

    46 void DevSoundWrapperSrc::InitializeComplete(TInt aError)

    47     {

    48     TRACE_PRN_FN_ENT;

    49     TRequestStatus* stat = &(AL->iStatus);

    50 

    51     if (aError == KErrNone)

    52         {

    53         init_complete = 1;

    54         }

    55     else

    56         {

    57         init_complete = 0;

    58         }

    59 

    60     User::RequestComplete(stat, aError);

    61     TRACE_PRN_FN_EXT;

    62     }

    63 /************************************************************/

    64 

    65 void DevSoundWrapperSrc::BufferToBeFilled(CMMFBuffer* /*aBuffer*/)

    66     {

    67     }

    68 

    69 /***********************************************************/

    70 void DevSoundWrapperSrc::PlayError(TInt /*aError*/)

    71     {

    72     }

    73 /*******************************************************/

    74 

    75 void DevSoundWrapperSrc::BufferToBeEmptied(CMMFBuffer* aBuffer)

    76     {

    77 //    TRACE_PRN_FN_ENT;

    78 

    79     buffer = aBuffer;

    80     bufferreadpos = 0;

    81     CMMFDataBuffer* buf = STATIC_CAST (CMMFDataBuffer*, buffer);

    82     buffersize = buf->Data().Length();

    83     TRACE_PRN_N1(_L("DevSoundWrapperSrc::BufferToBeEmptied->buffersize [%d]"), buffersize);

    84 

    85     TRequestStatus* stat = &(AL->iStatus);

    86     if (aBuffer)

    87         {

    88         User::RequestComplete(stat, KErrNone);

    89         iCallbackError = KErrNone;

    90         }

    91     else

    92         {

    93         User::RequestComplete(stat, KErrNotFound);

    94         iCallbackError = KErrNotFound;

    95         }

    96 //    TRACE_PRN_FN_EXT;

    97     }

    98 /********************************************************/

    99 

   100 void DevSoundWrapperSrc::RecordError(TInt aError)

   101     {

   102     TRACE_PRN_FN_ENT;

   103     TRACE_PRN_N1(_L("DevSoundWrapperSrc::RecordError %d"),aError);

   104     iCallbackError = aError;

   105     TRACE_PRN_FN_EXT;

   106     }

   107 /**********************************************************/

   108 

   109 void DevSoundWrapperSrc::ConvertError(TInt /*aError*/)

   110     {

   111 

   112     }

   113 /***********************************************************/

   114 void DevSoundWrapperSrc::DeviceMessage(TUid /*aMessageType*/, const TDesC8& /*aMsg*/)

   115     {

   116 

   117     }

   118 /***********************************************************/

   119 void DevSoundWrapperSrc::SendEventToClient(const TMMFEvent& /*aEvent*/)

   120     {

   121 

   122     }

   123 /************************************************************/

   124 void DevSoundWrapperSrc::ToneFinished(TInt /*aError*/)

   125     {

   126 

   127     }

   128 

   129 /***********************************************************

   130  *********C interface functions******************************

   131  ************************************************************/

   132 

   133 /******************************************************/

   134 int get_databuffer(DevSoundWrapperSrc *handle, const TUint8** buffer)

   135     {

   136     int ret = 0;

   137     CMMFDataBuffer* buf = STATIC_CAST (CMMFDataBuffer*, handle->buffer);

   138     *buffer = buf->Data().Ptr();

   139     if (buffer)

   140         {

   141         ret = KErrNone;

   142         }

   143     else

   144         {

   145         ret = KErrNotFound;

   146         }

   147     return ret;

   148     }

   149 

   150 /*********************************************************/

   151 int get_databuffer_size(DevSoundWrapperSrc *handle)

   152     {

   153     CMMFDataBuffer* buf = STATIC_CAST (CMMFDataBuffer*, handle->buffer);

   154     return buf->Data().Length();

   155     }

   156 

   157 /*********************************************************/

   158 int open_devsound(DevSoundWrapperSrc **handle)

   159     {

   160     TRACE_PRN_FN_ENT;

   161     int ret = 0;

   162     *handle = new DevSoundWrapperSrc();

   163     if (handle)

   164         {

   165         ret = open_device(handle);

   166         }

   167     else

   168         {

   169         ret = KErrNoMemory;

   170         }

   171     TRACE_PRN_FN_EXT;

   172     return ret;

   173     }

   174 

   175 /*******************************************************/

   176 int initialize_devsound(GstDevsoundSrc* ds)

   177     {

   178     TRACE_PRN_FN_ENT;

   179     int ret = 0;

   180     DevSoundWrapperSrc* handle = (DevSoundWrapperSrc*) ds->handle;

   181 

   182     handle->AL->InitialiseActiveListener();

   183 

   184         TRAP(ret, handle->dev_sound->InitializeL(*handle, handle->fourcc, EMMFStateRecording));

   185 

   186     if (ret)

   187         {

   188         TRACE_PRN_FN_EXT;

   189         return ret;

   190         }

   191 

   192     handle->AL->StartActiveScheduler();

   193 

   194     if (handle->init_complete == 1)

   195         {

   196         TMMFPrioritySettings temp;

   197         temp.iPref = (TMdaPriorityPreference) ds->preference;

   198         temp.iPriority = ds->priority;

   199         handle->dev_sound->SetPrioritySettings(temp);

   200 

   201         SetConfigurations(handle);

   202         ret = KErrNone;

   203         }

   204     else

   205         {

   206         ret = KErrNotFound;

   207         }

   208 

   209     TRACE_PRN_IF_ERR(ret);

   210     TRACE_PRN_FN_EXT;

   211     return ret;

   212     }

   213 /*********************************************************/

   214 

   215 int open_device(DevSoundWrapperSrc **handle)

   216     {

   217     int retcode = KErrNone;

   218     TRACE_PRN_FN_ENT;

   219 

   220     (*handle)->dev_count++;

   221 

   222     (*handle)->as = CActiveScheduler::Current();

   223 

   224     if (!((*handle)->as))

   225         {

   226         (*handle)->as = new CActiveScheduler();

   227         if ((*handle)->as)

   228             {

   229             CActiveScheduler::Install((*handle)->as);

   230             }

   231         }

   232 

   233     (*handle)->AL = new CActiveListener;

   234     ((*handle)->AL)->asw = new CActiveSchedulerWait();

   235 

   236         TRAP( retcode,(*handle)->dev_sound = CMMFDevSound::NewL() );

   237 

   238     if (!(*handle)->AL || !((*handle)->AL)->asw || !(*handle)->dev_sound

   239             || !(*handle)->as)

   240         {

   241         retcode = KErrNoMemory;

   242         }

   243 

   244     TRACE_PRN_FN_EXT;

   245 

   246     return retcode;

   247     }

   248 

   249 /*********************************************************/

   250 

   251 int close_devsound(GstDevsoundSrc *ds)

   252     {

   253     TRACE_PRN_FN_ENT;

   254     (STATIC_CAST(DevSoundWrapperSrc*, ds->handle))->dev_sound->Stop();

   255     g_list_foreach(ds->supportedbitrates, (GFunc) g_free, NULL);

   256     g_list_free(ds->supportedbitrates);

   257 

   258     g_list_foreach(ds->fmt, (GFunc) g_free, NULL);

   259     g_list_free(ds->fmt);

   260 

   261     delete ds->handle;

   262     TRACE_PRN_FN_EXT;

   263     return 0;

   264     }

   265 /************************************************************/

   266 

   267 int SetConfigurations(DevSoundWrapperSrc *handle)

   268     {

   269     TRACE_PRN_FN_ENT;

   270     int ret = 0;

   271 

   272     TMMFCapabilities temp_caps;

   273     temp_caps = (handle->dev_sound)->Capabilities();

   274 

   275     handle->gain = (handle->dev_sound)->MaxGain();

   276     (handle->dev_sound)->SetGain(handle->gain);

   277     handle->caps.iBufferSize = temp_caps.iBufferSize;

   278 

   279         TRAP(ret, (handle->dev_sound)->SetConfigL(handle->caps) );

   280     if (ret)

   281         {

   282         return ret;

   283         }

   284 

   285     (handle->caps) = (handle->dev_sound)->Config();

   286 

   287     switch (handle->fourcc)

   288         {

   289         case KMccFourCCIdG711:

   290             {

   291             if (!handle->iG711EncoderIntfc)

   292                 {

   293                     TRAP( ret, handle->iG711EncoderIntfc

   294                             = CG711EncoderIntfc::NewL(*handle->dev_sound) );

   295                 }

   296             break;

   297             }

   298         case KMccFourCCIdG729:

   299             {

   300             if (!handle->iG729EncoderIntfc)

   301                 {

   302                     TRAP( ret, handle->iG729EncoderIntfc

   303                             = CG729EncoderIntfc::NewL(*handle->dev_sound));

   304                 }

   305 

   306             break;

   307             }

   308         case KMccFourCCIdILBC:

   309             {

   310 

   311             if (!handle->iIlbcEncoderIntfc)

   312                 {

   313                     TRAP( ret, handle->iIlbcEncoderIntfc

   314                             = CIlbcEncoderIntfc::NewL(*handle->dev_sound));

   315                 }

   316 

   317             break;

   318             }

   319         default:

   320             {

   321             break;

   322             }

   323         }

   324 

   325     if (!handle->iSpeechEncoderConfig && handle->fourcc

   326             != KMMFFourCCCodePCM16)

   327         {

   328 

   329             TRAP(ret, handle->iSpeechEncoderConfig

   330                     = CSpeechEncoderConfig::NewL(*handle->dev_sound));

   331         }

   332 

   333     TRACE_PRN_FN_EXT;

   334     return ret;

   335     }

   336 

   337 void DevSoundWrapperSrc::GetSpeechEncoderProperties(GstDevsoundSrc* ds)

   338     {

   339     DevSoundWrapperSrc* dsPtr = STATIC_CAST(DevSoundWrapperSrc*, ds->handle);

   340     get_speech_encoder_supported_bit_rates(ds);

   341     get_speech_encoder_bit_rate(dsPtr, &ds->speechbitrate);

   342     get_speech_encoder_vad_mode(dsPtr, &ds->speechvadmode);

   343 

   344     }

   345 

   346 /*********************************************************/

   347 int get_speech_encoder_bit_rate(DevSoundWrapperSrc *handle, guint* aBitrate)

   348     {

   349     int err = 0;

   350     if (handle->iSpeechEncoderConfig)

   351         {

   352         err = (handle->iSpeechEncoderConfig)->GetBitrate(*aBitrate);

   353         }

   354     return err;

   355     }

   356 /*********************************************************/

   357 int get_speech_encoder_supported_bit_rates(GstDevsoundSrc *ds)

   358     {

   359     int err = 0;

   360     DevSoundWrapperSrc* dsPtr = STATIC_CAST(DevSoundWrapperSrc*, ds->handle);

   361         TRAP(err, err = dsPtr->GetSupportedBitratesL(ds));

   362 

   363     return err;

   364     }

   365 

   366 int DevSoundWrapperSrc::GetSupportedBitratesL(GstDevsoundSrc* ds)

   367     {

   368     int err = 0;

   369     DevSoundWrapperSrc* dsPtr = STATIC_CAST(DevSoundWrapperSrc*, ds->handle);

   370     if (dsPtr->iSpeechEncoderConfig)

   371         {

   372         RArray<TUint> bitrates;

   373 

   374         CleanupClosePushL(bitrates);

   375         err = (dsPtr->iSpeechEncoderConfig)->GetSupportedBitrates(bitrates);

   376         for (TInt i = 0; i < bitrates.Count(); i++)

   377             {

   378             guint *ip = g_new (guint, 1);

   379             *ip = bitrates[i];

   380             ds->supportedbitrates = g_list_append(ds->supportedbitrates, ip);

   381             }

   382         CleanupStack::PopAndDestroy(&bitrates);

   383         }

   384     return err;

   385     }

   386 

   387 /*********************************************************/

   388 int get_speech_encoder_vad_mode(DevSoundWrapperSrc *handle,

   389         gboolean* aVadMode)

   390     {

   391     int err = 0;

   392     if (handle->iSpeechEncoderConfig)

   393         {

   394         err = (handle->iSpeechEncoderConfig)->GetVadMode(*aVadMode);

   395         }

   396     return err;

   397     }

   398 

   399 /*********************************************************/

   400 int set_speech_encoder_bit_rate(DevSoundWrapperSrc *handle, guint aBitrate)

   401     {

   402     int err = 0;

   403     if (handle->iSpeechEncoderConfig)

   404         {

   405         err = (handle->iSpeechEncoderConfig)->SetBitrate(aBitrate);

   406         }

   407     return err;

   408     }

   409 

   410 /*********************************************************/

   411 int set_speech_encoder_vad_mode(DevSoundWrapperSrc *handle, gboolean aVadMode)

   412     {

   413     int err = 0;

   414     if (handle->iSpeechEncoderConfig)

   415         {

   416         err = (handle->iSpeechEncoderConfig)->SetVadMode(aVadMode);

   417         }

   418     return err;

   419     }

   420 

   421 /*********************************************************/

   422 int get_g711_encoder_vad_mode(DevSoundWrapperSrc *handle, gboolean* aVadMode)

   423     {

   424     int err = 0;

   425     if (handle->iG711EncoderIntfc)

   426         {

   427         err = (handle->iG711EncoderIntfc)->GetVadMode(*aVadMode);

   428         }

   429     return err;

   430     }

   431 

   432 /*********************************************************/

   433 int set_g711_encoder_mode(DevSoundWrapperSrc *handle,

   434         enum TG711EncodeMode aEncodeMode)

   435     {

   436     int err = 0;

   437     if (handle->iG711EncoderIntfc)

   438         {

   439         err = (handle->iG711EncoderIntfc)->SetEncoderMode(

   440                 (CG711EncoderIntfc::TEncodeMode) aEncodeMode);

   441         }

   442     return err;

   443     }

   444 

   445 /*********************************************************/

   446 int set_g711_vad_mode(DevSoundWrapperSrc *handle, gboolean aVadMode)

   447     {

   448     int err = 0;

   449     if (handle->iG711EncoderIntfc)

   450         {

   451         err = (handle->iG711EncoderIntfc)->SetVadMode(aVadMode);

   452         }

   453     return err;

   454     }

   455 

   456 /**************************************************************/

   457 int set_g729_vad_mode(DevSoundWrapperSrc *handle, TBool aVadMode)

   458     {

   459     int err = 0;

   460     if (handle->iG729EncoderIntfc)

   461         {

   462         err = (handle->iG729EncoderIntfc)->SetVadMode(aVadMode);

   463         }

   464     return err;

   465     }

   466 /**************************************************************/

   467 int get_g729_vad_mode(DevSoundWrapperSrc *handle, TBool* aVadMode)

   468     {

   469     int err = 0;

   470     if (handle->iG729EncoderIntfc)

   471         {

   472         err = (handle->iG729EncoderIntfc)->GetVadMode(*aVadMode);

   473         }

   474     return err;

   475     }

   476 /**************************************************************/

   477 int set_ilbc_encoder_mode(DevSoundWrapperSrc *handle,

   478         enum TIlbcEncodeMode aEncodeMode)

   479     {

   480     int err = 0;

   481     if (handle->iIlbcEncoderIntfc)

   482         {

   483         err = (handle->iIlbcEncoderIntfc)->SetEncoderMode(

   484                 (CIlbcEncoderIntfc::TEncodeMode) aEncodeMode);

   485         }

   486     return err;

   487     }

   488 /**************************************************************/

   489 int set_ilbc_vad_mode(DevSoundWrapperSrc *handle, gboolean aVadMode)

   490     {

   491     int err = 0;

   492     if (handle->iIlbcEncoderIntfc)

   493         {

   494         err = (handle->iIlbcEncoderIntfc)->SetVadMode(aVadMode);

   495         }

   496     return err;

   497     }

   498 /**************************************************************/

   499 int get_ilbc_vad_mode(DevSoundWrapperSrc *handle, gboolean* aVadMode)

   500     {

   501     int err = 0;

   502     if (handle->iIlbcEncoderIntfc)

   503         {

   504         err = (handle->iIlbcEncoderIntfc)->GetVadMode(*aVadMode);

   505         }

   506     return err;

   507     }

   508 

   509 /**************************************************************/

   510 int reset_devsound(DevSoundWrapperSrc */*handle*/)

   511     {

   512     return 0;

   513     }

   514 /*****************************************************************/

   515 int get_rate(DevSoundWrapperSrc *handle)

   516     {

   517     return handle->caps.iRate;

   518 

   519     }

   520 /*****************************************************************/

   521 int get_channels(DevSoundWrapperSrc *handle)

   522     {

   523     return handle->caps.iChannels;

   524 

   525     }

   526 /********************************************************************/

   527 int get_encoding(DevSoundWrapperSrc *handle)

   528     {

   529     return handle->caps.iEncoding;

   530     }

   531 /*******************************************************************/

   532 int get_size(DevSoundWrapperSrc *handle)

   533     {

   534     return handle->caps.iBufferSize;

   535     }

   536 /******************************************************************/

   537 

   538 void set_rate(DevSoundWrapperSrc *handle, int rate)

   539     {

   540     handle->caps.iRate = rate;

   541     }

   542 /******************************************************************/

   543 void set_channels(DevSoundWrapperSrc *handle, int channels)

   544     {

   545     handle->caps.iChannels = channels;

   546     }

   547 /****************************************************************/

   548 void set_encoding(DevSoundWrapperSrc *handle, int encoding)

   549     {

   550     handle->caps.iEncoding = encoding;

   551     }

   552 /*****************************************************************/

   553 void set_size(DevSoundWrapperSrc *handle, int size)

   554     {

   555     handle->caps.iBufferSize = size;

   556     }

   557 /*****************************************************************/

   558 void set_fourcc(DevSoundWrapperSrc *handle, int fourcc)

   559     {

   560     handle->fourcc = fourcc;

   561     }

   562 

   563 /*******************************************************************/

   564 

   565 int recordinit(DevSoundWrapperSrc *handle)

   566     {

   567     TRACE_PRN_FN_ENT;

   568     int ret = 0;

   569     ((handle)->AL)->InitialiseActiveListener();

   570     handle->iCallbackError = KErrNone;

   571 

   572         TRAP(ret, (handle->dev_sound)->RecordInitL() );

   573 

   574     if (ret)

   575         {

   576         TRACE_PRN_FN_EXT;

   577         return ret;

   578         }

   579     ((handle)->AL)->StartActiveScheduler();

   580 

   581     if ((handle->iCallbackError) != KErrNone)

   582         {

   583         TRACE_PRN_FN_EXT;

   584         return (handle->iCallbackError);

   585         }

   586     TRACE_PRN_FN_EXT;

   587     return KErrNone;

   588 

   589     }

   590 

   591 /*******************************************************************/

   592 int record_data(DevSoundWrapperSrc *handle)

   593     {

   594     TRACE_PRN_FN_ENT;

   595 

   596     (handle->AL)->InitialiseActiveListener();

   597     (handle->dev_sound)->RecordData();

   598     ((handle)->AL)->StartActiveScheduler();

   599 

   600     TRACE_PRN_FN_EXT;

   601     return KErrNone;

   602     }

   603 

   604 /*********************************************************************/

   605 

   606 int pre_init_setconf(GstDevsoundSrc *ds)

   607     {

   608     TRACE_PRN_FN_ENT;

   609     int ret = 0;

   610     DevSoundWrapperSrc* dsPtr = STATIC_CAST(DevSoundWrapperSrc*, ds->handle);

   611 

   612     // NOTE: it is too late for setting prio/pref here

   613     if (ds->pending.preferenceupdate == 1 || ds->pending.priorityupdate == 1)

   614         {

   615         ds->pending.preferenceupdate = FALSE;

   616         ds->pending.priorityupdate = FALSE;

   617         }

   618     if (ds->pending.gainupdate == 1)

   619         {

   620         (dsPtr->dev_sound)->SetGain(ds->gain);

   621         ds->pending.gainupdate = FALSE;

   622         }

   623 

   624     if (ds->pending.leftbalanceupdate == 1 || ds->pending.rightbalanceupdate

   625             == 1)

   626         {

   627 

   628             TRAP( ret, (dsPtr->dev_sound)->SetRecordBalanceL(ds->leftbalance,

   629                             ds->rightbalance) );

   630         ds->pending.leftbalanceupdate = FALSE;

   631         ds->pending.rightbalanceupdate = FALSE;

   632         }

   633     TRACE_PRN_FN_EXT;

   634     return ret;

   635     }

   636 /*********************************************************/

   637 void getsupporteddatatypes(GstDevsoundSrc *ds)

   638     {

   639     TRACE_PRN_FN_ENT;

   640     DevSoundWrapperSrc* dsPtr = STATIC_CAST(DevSoundWrapperSrc*, ds->handle);

   641         TRAP_IGNORE(dsPtr->GetDataTypesL(ds));

   642 

   643     TRACE_PRN_FN_EXT;

   644     }

   645 /*********************************************************/

   646 void DevSoundWrapperSrc::GetDataTypesL(GstDevsoundSrc *ds)

   647     {

   648     TRACE_PRN_FN_ENT;

   649 

   650     DevSoundWrapperSrc* dsPtr = STATIC_CAST(DevSoundWrapperSrc*, ds->handle);

   651     RArray<TFourCC> inputdatatypes;

   652     TMMFPrioritySettings prioritysettings;

   653 

   654     CleanupClosePushL(inputdatatypes);

   655 

   656     (dsPtr->dev_sound)->GetSupportedInputDataTypesL(inputdatatypes,

   657             prioritysettings);

   658 

   659     for (TInt i = 0; i < inputdatatypes.Count(); i++)

   660         {

   661         TRACE_PRN_N2(_L("GstDevsoundSrc supported Codec[%d]==[0x%x]"), i+1, inputdatatypes[i].FourCC());

   662         guint *ip = g_new (guint, 1);

   663         *ip = inputdatatypes[i].FourCC();

   664         ds->fmt = g_list_append(ds->fmt, ip);

   665         }

   666 

   667     CleanupStack::PopAndDestroy(&inputdatatypes);

   668     TRACE_PRN_FN_EXT;

   669     }

   670 /*********************************************************/

   671 void populateproperties(GstDevsoundSrc *ds)

   672     {

   673     TRACE_PRN_FN_ENT;

   674     DevSoundWrapperSrc* dsPtr = STATIC_CAST(DevSoundWrapperSrc*, ds->handle);

   675     ds->samplesrecorded = (dsPtr->dev_sound)->SamplesRecorded();

   676     TRACE_PRN_FN_EXT;

   677     }

   678 

   679 void initproperties(GstDevsoundSrc* ds)

   680     {

   681     TRACE_PRN_FN_ENT;

   682     DevSoundWrapperSrc* dsPtr=  STATIC_CAST(DevSoundWrapperSrc*, ds->handle);    

   683     ds->gain = (dsPtr->dev_sound)->Gain();

   684     ds->maxgain = (dsPtr->dev_sound)->MaxGain();

   685     dsPtr->GetSpeechEncoderProperties(ds);

   686     get_g711_encoder_vad_mode(dsPtr, &ds->g711vadmode);

   687     get_g729_vad_mode(dsPtr, &ds->g729vadmode);

   688     get_ilbc_vad_mode(dsPtr, &ds->ilbcvadmode);

   689     TRACE_PRN_FN_EXT;

   690     }

   691