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 

    19 #include "devsoundsrcwrapper.h"

    20 #include <e32base.h>

    21 #include <mmcccodecinformation.h>

    22 #include "debugtracemacros.h"

    23 

    24 DevSoundWrapperSrc::DevSoundWrapperSrc()

    25     {

    26     init_complete = 0;

    27     dev_sound = NULL;

    28     buffersize = 0;

    29     dev_count = 0;

    30     caps.iRate = EMMFSampleRate8000Hz;

    31     caps.iEncoding = EMMFSoundEncoding16BitPCM;

    32     caps.iChannels = EMMFMono;

    33     fourcc = KMMFFourCCCodePCM16;

    34     iCallbackError = KErrNone;

    35     iSpeechEncoderConfig = NULL;

    36     iG711EncoderIntfc = NULL;

    37     iG729EncoderIntfc = NULL;

    38     iIlbcEncoderIntfc = NULL;

    39     }

    40 

    41 /*********************************************************/

    42 void DevSoundWrapperSrc::InitializeComplete(TInt aError)

    43     {

    44     TRACE_PRN_FN_ENT;

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

    46 

    47     if (aError == KErrNone)

    48         {

    49         init_complete = 1;

    50         }

    51     else

    52         {

    53         init_complete = 0;

    54         }

    55 

    56     User::RequestComplete(stat, aError);

    57     TRACE_PRN_FN_EXT;

    58     }

    59 /************************************************************/

    60 

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

    62     {

    63     }

    64 

    65 /***********************************************************/

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

    67     {

    68     }

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

    70 

    71 void DevSoundWrapperSrc::BufferToBeEmptied(CMMFBuffer* aBuffer)

    72     {

    73 //    TRACE_PRN_FN_ENT;

    74 

    75     buffer = aBuffer;

    76     bufferreadpos = 0;

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

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

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

    80 

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

    82     if (aBuffer)

    83         {

    84         User::RequestComplete(stat, KErrNone);

    85         iCallbackError = KErrNone;

    86         }

    87     else

    88         {

    89         User::RequestComplete(stat, KErrNotFound);

    90         iCallbackError = KErrNotFound;

    91         }

    92 //    TRACE_PRN_FN_EXT;

    93     }

    94 /********************************************************/

    95 

    96 void DevSoundWrapperSrc::RecordError(TInt aError)

    97     {

    98     TRACE_PRN_FN_ENT;

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

   100     iCallbackError = aError;

   101     TRACE_PRN_FN_EXT;

   102     }

   103 /**********************************************************/

   104 

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

   106     {

   107 

   108     }

   109 /***********************************************************/

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

   111     {

   112 

   113     }

   114 /***********************************************************/

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

   116     {

   117 

   118     }

   119 /************************************************************/

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

   121     {

   122 

   123     }

   124 

   125 /***********************************************************

   126  *********C interface functions******************************

   127  ************************************************************/

   128 

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

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

   131     {

   132     int ret = 0;

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

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

   135     if (buffer)

   136         {

   137         ret = KErrNone;

   138         }

   139     else

   140         {

   141         ret = KErrNotFound;

   142         }

   143     return ret;

   144     }

   145 

   146 /*********************************************************/

   147 int get_databuffer_size(DevSoundWrapperSrc *handle)

   148     {

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

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

   151     }

   152 

   153 /*********************************************************/

   154 int open_devsound(DevSoundWrapperSrc **handle)

   155     {

   156     TRACE_PRN_FN_ENT;

   157     int ret = 0;

   158     *handle = new DevSoundWrapperSrc();

   159     if (handle)

   160         {

   161         ret = open_device(handle);

   162         }

   163     else

   164         {

   165         ret = KErrNoMemory;

   166         }

   167     TRACE_PRN_FN_EXT;

   168     return ret;

   169     }

   170 

   171 /*******************************************************/

   172 int initialize_devsound(GstDevsoundSrc* ds)

   173     {

   174     TRACE_PRN_FN_ENT;

   175     int ret = 0;

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

   177 

   178     handle->AL->InitialiseActiveListener();

   179 

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

   181 

   182     if (ret)

   183         {

   184         TRACE_PRN_FN_EXT;

   185         return ret;

   186         }

   187 

   188     handle->AL->StartActiveScheduler();

   189 

   190     if (handle->init_complete == 1)

   191         {

   192         TMMFPrioritySettings temp;

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

   194         temp.iPriority = ds->priority;

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

   196 

   197         SetConfigurations(handle);

   198         ret = KErrNone;

   199         }

   200     else

   201         {

   202         ret = KErrNotFound;

   203         }

   204 

   205     TRACE_PRN_IF_ERR(ret);

   206     TRACE_PRN_FN_EXT;

   207     return ret;

   208     }

   209 /*********************************************************/

   210 

   211 int open_device(DevSoundWrapperSrc **handle)

   212     {

   213     int retcode = KErrNone;

   214     TRACE_PRN_FN_ENT;

   215 

   216     (*handle)->dev_count++;

   217 

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

   219 

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

   221         {

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

   223         if ((*handle)->as)

   224             {

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

   226             }

   227         }

   228 

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

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

   231 

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

   233 

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

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

   236         {

   237         retcode = KErrNoMemory;

   238         }

   239 

   240     TRACE_PRN_FN_EXT;

   241 

   242     return retcode;

   243     }

   244 

   245 /*********************************************************/

   246 

   247 int close_devsound(GstDevsoundSrc *ds)

   248     {

   249     TRACE_PRN_FN_ENT;

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

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

   252     g_list_free(ds->supportedbitrates);

   253 

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

   255     g_list_free(ds->fmt);

   256 

   257     delete ds->handle;

   258     TRACE_PRN_FN_EXT;

   259     return 0;

   260     }

   261 /************************************************************/

   262 

   263 int SetConfigurations(DevSoundWrapperSrc *handle)

   264     {

   265     TRACE_PRN_FN_ENT;

   266     int ret = 0;

   267 

   268     TMMFCapabilities temp_caps;

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

   270 

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

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

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

   274 

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

   276     if (ret)

   277         {

   278         return ret;

   279         }

   280 

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

   282 

   283     switch (handle->fourcc)

   284         {

   285         case KMccFourCCIdG711:

   286             {

   287             if (!handle->iG711EncoderIntfc)

   288                 {

   289                     TRAP( ret, handle->iG711EncoderIntfc

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

   291                 }

   292             break;

   293             }

   294         case KMccFourCCIdG729:

   295             {

   296             if (!handle->iG729EncoderIntfc)

   297                 {

   298                     TRAP( ret, handle->iG729EncoderIntfc

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

   300                 }

   301 

   302             break;

   303             }

   304         case KMccFourCCIdILBC:

   305             {

   306 

   307             if (!handle->iIlbcEncoderIntfc)

   308                 {

   309                     TRAP( ret, handle->iIlbcEncoderIntfc

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

   311                 }

   312 

   313             break;

   314             }

   315         default:

   316             {

   317             break;

   318             }

   319         }

   320 

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

   322             != KMMFFourCCCodePCM16)

   323         {

   324 

   325             TRAP(ret, handle->iSpeechEncoderConfig

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

   327         }

   328 

   329     TRACE_PRN_FN_EXT;

   330     return ret;

   331     }

   332 

   333 void DevSoundWrapperSrc::GetSpeechEncoderProperties(GstDevsoundSrc* ds)

   334     {

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

   336     get_speech_encoder_supported_bit_rates(ds);

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

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

   339 

   340     }

   341 

   342 /*********************************************************/

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

   344     {

   345     int err = 0;

   346     if (handle->iSpeechEncoderConfig)

   347         {

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

   349         }

   350     return err;

   351     }

   352 /*********************************************************/

   353 int get_speech_encoder_supported_bit_rates(GstDevsoundSrc *ds)

   354     {

   355     int err = 0;

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

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

   358 

   359     return err;

   360     }

   361 

   362 int DevSoundWrapperSrc::GetSupportedBitratesL(GstDevsoundSrc* ds)

   363     {

   364     int err = 0;

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

   366     if (dsPtr->iSpeechEncoderConfig)

   367         {

   368         RArray<TUint> bitrates;

   369 

   370         CleanupClosePushL(bitrates);

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

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

   373             {

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

   375             *ip = bitrates[i];

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

   377             }

   378         CleanupStack::PopAndDestroy(&bitrates);

   379         }

   380     return err;

   381     }

   382 

   383 /*********************************************************/

   384 int get_speech_encoder_vad_mode(DevSoundWrapperSrc *handle,

   385         gboolean* aVadMode)

   386     {

   387     int err = 0;

   388     if (handle->iSpeechEncoderConfig)

   389         {

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

   391         }

   392     return err;

   393     }

   394 

   395 /*********************************************************/

   396 int set_speech_encoder_bit_rate(DevSoundWrapperSrc *handle, guint aBitrate)

   397     {

   398     int err = 0;

   399     if (handle->iSpeechEncoderConfig)

   400         {

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

   402         }

   403     return err;

   404     }

   405 

   406 /*********************************************************/

   407 int set_speech_encoder_vad_mode(DevSoundWrapperSrc *handle, gboolean aVadMode)

   408     {

   409     int err = 0;

   410     if (handle->iSpeechEncoderConfig)

   411         {

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

   413         }

   414     return err;

   415     }

   416 

   417 /*********************************************************/

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

   419     {

   420     int err = 0;

   421     if (handle->iG711EncoderIntfc)

   422         {

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

   424         }

   425     return err;

   426     }

   427 

   428 /*********************************************************/

   429 int set_g711_encoder_mode(DevSoundWrapperSrc *handle,

   430         enum TG711EncodeMode aEncodeMode)

   431     {

   432     int err = 0;

   433     if (handle->iG711EncoderIntfc)

   434         {

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

   436                 (CG711EncoderIntfc::TEncodeMode) aEncodeMode);

   437         }

   438     return err;

   439     }

   440 

   441 /*********************************************************/

   442 int set_g711_vad_mode(DevSoundWrapperSrc *handle, gboolean aVadMode)

   443     {

   444     int err = 0;

   445     if (handle->iG711EncoderIntfc)

   446         {

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

   448         }

   449     return err;

   450     }

   451 

   452 /**************************************************************/

   453 int set_g729_vad_mode(DevSoundWrapperSrc *handle, TBool aVadMode)

   454     {

   455     int err = 0;

   456     if (handle->iG729EncoderIntfc)

   457         {

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

   459         }

   460     return err;

   461     }

   462 /**************************************************************/

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

   464     {

   465     int err = 0;

   466     if (handle->iG729EncoderIntfc)

   467         {

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

   469         }

   470     return err;

   471     }

   472 /**************************************************************/

   473 int set_ilbc_encoder_mode(DevSoundWrapperSrc *handle,

   474         enum TIlbcEncodeMode aEncodeMode)

   475     {

   476     int err = 0;

   477     if (handle->iIlbcEncoderIntfc)

   478         {

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

   480                 (CIlbcEncoderIntfc::TEncodeMode) aEncodeMode);

   481         }

   482     return err;

   483     }

   484 /**************************************************************/

   485 int set_ilbc_vad_mode(DevSoundWrapperSrc *handle, gboolean aVadMode)

   486     {

   487     int err = 0;

   488     if (handle->iIlbcEncoderIntfc)

   489         {

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

   491         }

   492     return err;

   493     }

   494 /**************************************************************/

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

   496     {

   497     int err = 0;

   498     if (handle->iIlbcEncoderIntfc)

   499         {

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

   501         }

   502     return err;

   503     }

   504 

   505 /**************************************************************/

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

   507     {

   508     return 0;

   509     }

   510 /*****************************************************************/

   511 int get_rate(DevSoundWrapperSrc *handle)

   512     {

   513     return handle->caps.iRate;

   514 

   515     }

   516 /*****************************************************************/

   517 int get_channels(DevSoundWrapperSrc *handle)

   518     {

   519     return handle->caps.iChannels;

   520 

   521     }

   522 /********************************************************************/

   523 int get_encoding(DevSoundWrapperSrc *handle)

   524     {

   525     return handle->caps.iEncoding;

   526     }

   527 /*******************************************************************/

   528 int get_size(DevSoundWrapperSrc *handle)

   529     {

   530     return handle->caps.iBufferSize;

   531     }

   532 /******************************************************************/

   533 

   534 void set_rate(DevSoundWrapperSrc *handle, int rate)

   535     {

   536     handle->caps.iRate = rate;

   537     }

   538 /******************************************************************/

   539 void set_channels(DevSoundWrapperSrc *handle, int channels)

   540     {

   541     handle->caps.iChannels = channels;

   542     }

   543 /****************************************************************/

   544 void set_encoding(DevSoundWrapperSrc *handle, int encoding)

   545     {

   546     handle->caps.iEncoding = encoding;

   547     }

   548 /*****************************************************************/

   549 void set_size(DevSoundWrapperSrc *handle, int size)

   550     {

   551     handle->caps.iBufferSize = size;

   552     }

   553 /*****************************************************************/

   554 void set_fourcc(DevSoundWrapperSrc *handle, int fourcc)

   555     {

   556     handle->fourcc = fourcc;

   557     }

   558 

   559 /*******************************************************************/

   560 

   561 int recordinit(DevSoundWrapperSrc *handle)

   562     {

   563     TRACE_PRN_FN_ENT;

   564     int ret = 0;

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

   566     handle->iCallbackError = KErrNone;

   567 

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

   569 

   570     if (ret)

   571         {

   572         TRACE_PRN_FN_EXT;

   573         return ret;

   574         }

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

   576 

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

   578         {

   579         TRACE_PRN_FN_EXT;

   580         return (handle->iCallbackError);

   581         }

   582     TRACE_PRN_FN_EXT;

   583     return KErrNone;

   584 

   585     }

   586 

   587 /*******************************************************************/

   588 int record_data(DevSoundWrapperSrc *handle)

   589     {

   590     TRACE_PRN_FN_ENT;

   591 

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

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

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

   595 

   596     TRACE_PRN_FN_EXT;

   597     return KErrNone;

   598     }

   599 

   600 /*********************************************************************/

   601 

   602 int pre_init_setconf(GstDevsoundSrc *ds)

   603     {

   604     TRACE_PRN_FN_ENT;

   605     int ret = 0;

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

   607 

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

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

   610         {

   611         ds->pending.preferenceupdate = FALSE;

   612         ds->pending.priorityupdate = FALSE;

   613         }

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

   615         {

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

   617         ds->pending.gainupdate = FALSE;

   618         }

   619 

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

   621             == 1)

   622         {

   623 

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

   625                             ds->rightbalance) );

   626         ds->pending.leftbalanceupdate = FALSE;

   627         ds->pending.rightbalanceupdate = FALSE;

   628         }

   629     TRACE_PRN_FN_EXT;

   630     return ret;

   631     }

   632 /*********************************************************/

   633 void getsupporteddatatypes(GstDevsoundSrc *ds)

   634     {

   635     TRACE_PRN_FN_ENT;

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

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

   638 

   639     TRACE_PRN_FN_EXT;

   640     }

   641 /*********************************************************/

   642 void DevSoundWrapperSrc::GetDataTypesL(GstDevsoundSrc *ds)

   643     {

   644     TRACE_PRN_FN_ENT;

   645 

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

   647     RArray<TFourCC> inputdatatypes;

   648     TMMFPrioritySettings prioritysettings;

   649 

   650     CleanupClosePushL(inputdatatypes);

   651 

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

   653             prioritysettings);

   654 

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

   656         {

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

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

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

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

   661         }

   662 

   663     CleanupStack::PopAndDestroy(&inputdatatypes);

   664     TRACE_PRN_FN_EXT;

   665     }

   666 /*********************************************************/

   667 void populateproperties(GstDevsoundSrc *ds)

   668     {

   669     TRACE_PRN_FN_ENT;

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

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

   672     TRACE_PRN_FN_EXT;

   673     }

   674 

   675 void initproperties(GstDevsoundSrc* ds)

   676     {

   677     TRACE_PRN_FN_ENT;

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

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

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

   681     dsPtr->GetSpeechEncoderProperties(ds);

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

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

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

   685     TRACE_PRN_FN_EXT;

   686     }

   687