1 /*

     2  * Copyright (c) 2007-2008 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: VoIP audio server session class implementation.

    15  *              Each session is created either for an uplink, downlink or

    16  *              ring tone player. Separate thread is created for uplink and

    17  *              downlink stream. Ring tone player runs in the main thread.

    18  *

    19  */

    20 

    21 #include <AudioPreference.h>

    22 #include <MProEngEngine.h>

    23 #include <MProEngProfile.h>

    24 #include <MProEngTones.h>

    25 #include <ProEngFactory.h>

    26 #include <voipaudiocommon.h>

    27 #include "debugtracemacros.h"

    28 #include "VoIPAudioSession.h"

    29 #include "VoIPServerThread.h"

    30 #include "VoIPSharedData.h"

    31 #include "VoIPServerSession.h"

    32 

    33 // These are the default tone length settings for the US

    34 const TUint KDTMFToneLengthOn = 250000;

    35 const TUint KDTMFToneLengthOff = 50000;

    36 const TUint KDTMFToneLengthPause = 2500000;

    37 const TUint KArrayExpandSize = 8;

    38 

    39 // -----------------------------------------------------------------------------

    40 // CVoIPAudioServerSession::NewL

    41 // Symbian constructor.

    42 // -----------------------------------------------------------------------------

    43 //

    44 CVoIPAudioServerSession* CVoIPAudioServerSession::NewL(

    45         CVoIPAudioServer &aServer)

    46     {

    47     CVoIPAudioServerSession* self = new (ELeave) CVoIPAudioServerSession(

    48             aServer);

    49     CleanupStack::PushL(self);

    50     self->ConstructL();

    51     CleanupStack::Pop(self);

    52     return self;

    53     }

    54 

    55 // -----------------------------------------------------------------------------

    56 // CVoIPAudioServerSession::~CVoIPAudioServerSession

    57 // The destructor

    58 // -----------------------------------------------------------------------------

    59 //

    60 CVoIPAudioServerSession::~CVoIPAudioServerSession()

    61     {

    62     TRACE_PRN_FN_ENT;

    63 

    64     if (iAO)

    65         {

    66         iAO->Cancel();

    67         delete iAO;

    68         }

    69 

    70     delete iDevSound;

    71     delete iToneBuf;

    72     delete iRingTonePlayer;

    73     delete iDTMFTonePlayer;

    74     iCodecsUp.Reset();

    75     iCodecsUp.Close();

    76     iCodecsDn.Reset();

    77     iCodecsDn.Close();

    78 

    79     if (iThread.Handle() > 0)

    80         {

    81         iThread.Close(); // close thread handle

    82         }

    83 

    84     if (iMsgComQueueDtmf.Handle() > 0)

    85         {

    86         iMsgComQueueDtmf.Close();

    87         }

    88 

    89     if (iMsgComQueue.Handle() > 0)

    90         {

    91         iMsgComQueue.Close();

    92         }

    93 

    94     if (iITCMsgComQueue.Handle() > 0)

    95         {

    96         iITCMsgComQueue.Close();

    97         }

    98 

    99     iShared.iMutex.Close();

   100     iShared.iCodecSettings.iArrBitrates.Reset();

   101 

   102     iVoIPServer.DropSession(); // will start shutdown if no more sessions left

   103 

   104     // Release memory and close handles to unused plug-ins held by the DevSound

   105     REComSession::FinalClose();

   106 

   107     TRACE_PRN_FN_EXT;

   108     }

   109 

   110 // -----------------------------------------------------------------------------

   111 // CVoIPAudioServerSession::ConstructL

   112 // 2-nd phase constructor.

   113 // -----------------------------------------------------------------------------

   114 //

   115 void CVoIPAudioServerSession::ConstructL()

   116     {

   117     TRACE_PRN_FN_ENT;

   118 

   119     // Create semaphore for thread signaling when accessing shared data

   120     iShared.iMutex.CreateLocal();

   121 

   122     // Setup A/O for ITC to receive callbacks from the uplink/downlink threads

   123     // Note: Must replace with msg queue if multiple callbacks can be

   124     //       received at the same time.

   125     TThreadId tID = RThread().Id();

   126     iShared.iMutex.Wait();

   127     iShared.iMainThreadID = tID;

   128     iAO = new (ELeave) CVoIPServerAO(this, tID);

   129     iShared.iMnThreadStatus = &(this->iAO->iStatus);

   130     iShared.iMutex.Signal();

   131     iShared.iCodecSettings.iG711FrameRate = TVoIPCodecSettings::E20MS;

   132     iAO->Request();

   133     iSessionType = ENone;

   134 

   135     TRACE_PRN_FN_EXT;

   136     }

   137 

   138 // -----------------------------------------------------------------------------

   139 // CVoIPAudioServerSession::CVoIPAudioServerSession

   140 // -----------------------------------------------------------------------------

   141 //

   142 CVoIPAudioServerSession::CVoIPAudioServerSession(CVoIPAudioServer &aServer) :

   143     iVoIPServer(aServer)

   144     {

   145     TRACE_PRN_FN_ENT;

   146     iVoIPServer.AddSession(); //add new session

   147     TRACE_PRN_FN_EXT;

   148     }

   149 

   150 // -----------------------------------------------------------------------------

   151 // CVoIPAudioServerSession::ServiceL

   152 // Service request handler.

   153 // -----------------------------------------------------------------------------

   154 //

   155 void CVoIPAudioServerSession::ServiceL(const RMessage2& aMessage)

   156     {

   157     TRAPD(err, DispatchMessageL(aMessage));

   158     if (!iMsgQueued)

   159         {

   160         aMessage.Complete(err);

   161         }

   162     }

   163 

   164 // -----------------------------------------------------------------------------

   165 // CVoIPAudioServerSession::DispatchMessageL

   166 // Service request handler.

   167 // -----------------------------------------------------------------------------

   168 //

   169 void CVoIPAudioServerSession::DispatchMessageL(const RMessage2& aMessage)

   170     {

   171     switch (aMessage.Function())

   172         {

   173         case EVoIPSetEncoderPriority:

   174         case EVoIPSetDecoderPriority:

   175             SetPriorityL(aMessage);

   176             break;

   177         case EVoIPGetSupportedEncodersCount:

   178             if (iSessionType == ENone)

   179                 {

   180                 iSessionType = EQueryEnc;

   181                 }

   182             GetCodecsCountL(aMessage);

   183             break;

   184         case EVoIPGetSupportedDecodersCount:

   185             if (iSessionType == ENone)

   186                 {

   187                 iSessionType = EQueryDec;

   188                 }

   189             GetCodecsCountL(aMessage);

   190             break;

   191         case EVoIPGetSupportedEncoders:

   192             if (iSessionType == ENone)

   193                 {

   194                 iSessionType = EQueryEnc;

   195                 }

   196             GetSupportedCodecsL(aMessage);

   197             break;

   198         case EVoIPGetSupportedDecoders:

   199             GetSupportedCodecsL(aMessage);

   200             break;

   201         case EVoIPSetDecoder:

   202             if (iSessionType == ENone)

   203                 {

   204                 iSessionType = EQueryDec;

   205                 }

   206             SetFormatL(aMessage);

   207             break;

   208         case EVoIPSetEncoder:

   209             if (iSessionType == ENone)

   210                 {

   211                 iSessionType = EQueryEnc;

   212                 }

   213             SetFormatL(aMessage);

   214             break;

   215         case EVoIPOpenDownlink:

   216             OpenDownlinkL(aMessage);

   217             break;

   218         case EVoIPOpenUplink:

   219             OpenUplinkL(aMessage);

   220             break;

   221         case EVoIPStartDownlink:

   222             StartDownlink();

   223             break;

   224         case EVoIPStartUplink:

   225             StartUplink();

   226             break;

   227         case EVoIPStopDownlink:

   228             StopDownlink();

   229             break;

   230         case EVoIPStopUplink:

   231             StopUplink();

   232             break;

   233         case EVoIPCloseDownlink:

   234             CloseDownlink();

   235             break;

   236         case EVoIPCloseUplink:

   237             CloseUplink();

   238             break;

   239         case EVoIPGetMaxVolume:

   240             GetMaxVolumeL(aMessage);

   241             break;

   242         case EVoIPGetVolume:

   243             GetVolume(aMessage);

   244             break;

   245         case EVoIPSetVolume:

   246             SetVolume(aMessage);

   247             break;

   248         case EVoIPGetMaxGain:

   249             GetMaxGainL(aMessage);

   250             break;

   251         case EVoIPGetGain:

   252             GetGain(aMessage);

   253             break;

   254         case EVoIPSetGain:

   255             SetGain(aMessage);

   256             break;

   257         case EVoIPSetAudioDevice:

   258             SetAudioDeviceL(aMessage);

   259             break;

   260         case EVoIPGetAudioDevice:

   261             GetAudioDevice(aMessage);

   262             break;

   263         case EVoIPBufferFilled:

   264             BufferFilledL(aMessage);

   265             break;

   266         case EVoIPBufferEmptied:

   267             BufferEmptiedL(aMessage);

   268             break;

   269         case EVoIPSetIlbcCodecMode:

   270             SetIlbcCodecModeL(aMessage);

   271             break;

   272         case EVoIPGetIlbcCodecMode:

   273             GetIlbcCodecMode(aMessage);

   274             break;

   275         case EVoIPSetG711CodecMode:

   276             SetG711CodecModeL(aMessage);

   277             break;

   278         case EVoIPGetG711CodecMode:

   279             GetG711CodecMode(aMessage);

   280             break;

   281         case EVoIPGetSupportedBitratesCount:

   282             GetSupportedBitratesCount(aMessage);

   283             break;

   284         case EVoIPGetSupportedBitrates:

   285             GetSupportedBitratesL(aMessage);

   286             break;

   287         case EVoIPSetBitrate:

   288             SetBitrate(aMessage);

   289             break;

   290         case EVoIPGetBitrate:

   291             GetBitrate(aMessage);

   292             break;

   293         case EVoIPFrameModeRqrdForEC:

   294             FrameModeRqrdForEC(aMessage);

   295             break;

   296         case EVoIPSetFrameMode:

   297             SetFrameMode(aMessage);

   298             break;

   299         case EVoIPGetFrameMode:

   300             GetFrameMode(aMessage);

   301             break;

   302         case EVoIPConcealErrForNextBuf:

   303             ConcealErrorForNextBuffer();

   304             break;

   305         case EVoIPSetVad:

   306             SetVad(aMessage);

   307             break;

   308         case EVoIPGetVad:

   309             GetVad(aMessage);

   310             break;

   311         case EVoIPSetCng:

   312             SetCng(aMessage);

   313             break;

   314         case EVoIPGetCng:

   315             GetCng(aMessage);

   316             break;

   317         case EVoIPSetPlc:

   318             SetPlc(aMessage);

   319             break;

   320         case EVoIPGetPlc:

   321             GetPlc(aMessage);

   322             break;

   323         case EVoIPBadLsfNextBuffer:

   324             BadLsfNextBuffer();

   325             break;

   326         case EVoIPOpenDTMFTonePlayer:

   327             OpenDTMFTonePlayerL();

   328             break;

   329         case EVoIPPlayDTMFTone:

   330             PlayDTMFToneL(aMessage);

   331             break;

   332         case EVoIPStopDTMFTone:

   333             StopDTMFTonePlay();

   334             break;

   335         case EVoIPCloseDTMFTonePlayer:

   336             CloseDTMFTonePlayer();

   337             break;

   338         case EVoIPOpenRingTonePlayerFromFile:

   339             OpenRingTonePlayerFromFileL(aMessage);

   340             break;

   341         case EVoIPOpenRingTonePlayerFromRFile:

   342             OpenRingTonePlayerFromRFileL(aMessage);

   343             break;

   344         case EVoIPOpenRingTonePlayerFromProfile:

   345             OpenRingTonePlayerFromProfileL();

   346             break;

   347         case EVoIPOpenRingTonePlayerFromDes:

   348             OpenRingTonePlayerFromDesL(aMessage);

   349             break;

   350         case EVoIPPlayRingTone:

   351             PlayRingTone();

   352             break;

   353         case EVoIPPauseRingTone:

   354             PauseRingTone();

   355             break;

   356         case EVoIPResumeRingTone:

   357             ResumeRingTone();

   358             break;

   359         case EVoIPStopRingTone:

   360             StopRingTone();

   361             break;

   362         case EVoIPCloseRingTonePlayer:

   363             CloseRingTonePlayer();

   364             break;

   365         case EVoIPConfigJitterBuffer:

   366             ConfigureJitterBufferL(aMessage);

   367             break;

   368         case EVoIPResetJitterBuffer:

   369             ResetJitterBuffer(aMessage);

   370             break;

   371         case EVoIPJBDelayDown:

   372             JBDelayDown();

   373             break;

   374         case EVoIPJBDelayUp:

   375             JBDelayUp();

   376             break;

   377         case EVoIPSessionClose:

   378             break;

   379         default:

   380             User::Leave(KErrNotSupported);

   381             break;

   382         }

   383     }

   384 

   385 // -----------------------------------------------------------------------------

   386 // CVoIPAudioServerSession::SetDecoderPriority

   387 //

   388 // -----------------------------------------------------------------------------

   389 //

   390 void CVoIPAudioServerSession::SetPriorityL(const RMessage2& aMessage)

   391     {

   392     TMMFPrioritySettingsPckg pckg;

   393     aMessage.ReadL(0, pckg);

   394     iPriority = pckg();

   395     iShared.iMutex.Wait();

   396     iShared.iPreference = iPriority.iPref;

   397     iShared.iPriority = iPriority.iPriority;

   398     iShared.iMutex.Signal();

   399     }

   400 

   401 // -----------------------------------------------------------------------------

   402 // CVoIPAudioServerSession::GetCodecsCountL

   403 //

   404 // -----------------------------------------------------------------------------

   405 //

   406 void CVoIPAudioServerSession::GetCodecsCountL(const RMessage2& aMessage)

   407     {

   408     TRACE_PRN_FN_ENT;

   409 

   410     TVoIPMsgBufPckg p;

   411     p().iStatus = KErrNone;

   412     p().iInt = 0;

   413 

   414     // Is codecs info already available?

   415     if (iCodecsCountUp > 0 &&

   416        (iSessionType == EQueryEnc || iSessionType == EUplink))

   417         {

   418         p().iInt = iCodecsCountUp;

   419         iShared.iMutex.Wait();

   420         p().iUint = iShared.iCodecSettings.iG711FrameRate; //TODO:

   421         iShared.iMutex.Signal();

   422         }

   423     else if (iCodecsCountDn > 0 &&

   424             (iSessionType == EQueryDec || iSessionType == EDnlink))

   425         {

   426         p().iInt = iCodecsCountDn;

   427         iShared.iMutex.Wait();

   428         p().iUint = iShared.iCodecSettings.iG711FrameRate; //TODO:

   429         iShared.iMutex.Signal();

   430         }

   431     else

   432         {

   433         delete iDevSound;

   434         iDevSound = NULL;

   435         iDevSound = CMMFDevSound::NewL();

   436 

   437         if (iDevSound)

   438             {

   439             iCodecsUp.Reset();

   440             iCodecsCountUp = 0;

   441             iDevSound->GetSupportedInputDataTypesL(iCodecsUp, iPriority);

   442 /*

   443 #ifdef __WINSCW__

   444             // Support for adaptation stubs

   445             iCodecsUp.Append(KMccFourCCIdG711);

   446             iCodecsUp.Append(KMccFourCCIdG729);

   447             iCodecsUp.Append(KMccFourCCIdILBC);

   448             iCodecsUp.Append(KMccFourCCIdAMRNB);

   449 #endif

   450 */

   451             iCodecsCountUp = iCodecsUp.Count();

   452 

   453             iCodecsDn.Reset();

   454             iCodecsCountDn = 0;

   455             iDevSound->GetSupportedOutputDataTypesL(iCodecsDn, iPriority);

   456 /*

   457 #ifdef __WINSCW__

   458             // Support for adaptation stubs

   459             iCodecsDn.Append(KMccFourCCIdG711);

   460             iCodecsDn.Append(KMccFourCCIdG729);

   461             iCodecsDn.Append(KMccFourCCIdILBC);

   462             iCodecsDn.Append(KMccFourCCIdAMRNB);

   463 #endif

   464 */

   465             iCodecsCountDn = iCodecsDn.Count();

   466             }

   467         }

   468 

   469     delete iDevSound;

   470     iDevSound = NULL;

   471 

   472     if (iSessionType == EQueryEnc || iSessionType == EUplink)

   473         {

   474         p().iInt = iCodecsCountUp;

   475         }

   476     else if (iSessionType == EQueryDec || iSessionType == EDnlink)

   477         {

   478         p().iInt = iCodecsCountDn;

   479         }

   480 

   481     p().iUint = KVoIPG711FrameLen20ms; //good for 10ms and 20ms

   482     aMessage.WriteL(0, p);

   483 

   484     TRACE_PRN_FN_EXT;

   485     }

   486 

   487 // -----------------------------------------------------------------------------

   488 // CVoIPAudioServerSession::GetSupportedEncodersL

   489 //

   490 // -----------------------------------------------------------------------------

   491 //

   492 void CVoIPAudioServerSession::GetSupportedCodecsL(const RMessage2& aMessage)

   493     {

   494     TRACE_PRN_FN_ENT;

   495 

   496     CBufFlat* dataCopyBuffer = CBufFlat::NewL(KArrayExpandSize);

   497     CleanupStack::PushL(dataCopyBuffer);

   498     RBufWriteStream stream;

   499     stream.Open(*dataCopyBuffer);

   500     CleanupClosePushL(stream);

   501 

   502     if (iCodecsCountUp > 0 &&

   503        (iSessionType == EQueryEnc || iSessionType == EUplink))

   504         {

   505         for (TInt i = 0; i < iCodecsCountUp; i++)

   506             {

   507             stream.WriteUint32L(iCodecsUp[i].FourCC());

   508             TRACE_PRN_N2(_L("VoIP->CodecUP[%d]==[0x%x]"), i+1, iCodecsUp[i].FourCC());

   509             }

   510         }

   511     else if (iCodecsCountDn > 0 &&

   512             (iSessionType == EQueryDec || iSessionType == EDnlink))

   513         {

   514         for (TInt i = 0; i < iCodecsCountDn; i++)

   515             {

   516             stream.WriteUint32L(iCodecsDn[i].FourCC());

   517             TRACE_PRN_N2(_L("VoIP->CodecDN[%d]==[0x%x]"), i+1, iCodecsDn[i].FourCC());

   518             }

   519         }

   520 

   521     aMessage.WriteL(0, dataCopyBuffer->Ptr(0));

   522 

   523     CleanupStack::PopAndDestroy(&stream);

   524     CleanupStack::PopAndDestroy(dataCopyBuffer);

   525 

   526     TRACE_PRN_FN_EXT;

   527     }

   528 

   529 // -----------------------------------------------------------------------------

   530 // CVoIPAudioServerSession::OpenDownlinkL

   531 // Method for player initialization.

   532 // -----------------------------------------------------------------------------

   533 //

   534 void CVoIPAudioServerSession::OpenDownlinkL(const RMessage2& aMessage)

   535     {

   536     TRACE_PRN_FN_ENT;

   537 

   538     TMMFPrioritySettingsPckg pckg;

   539     aMessage.ReadL(0, pckg);

   540     iShared.iMutex.Wait();

   541     iShared.iPreference = pckg().iPref;

   542     iShared.iPriority = pckg().iPriority;

   543     iShared.iMutex.Signal();

   544 

   545     TInt err = KErrPermissionDenied;

   546 

   547     if (iVoIPServer.HasDnLinkSession())

   548         {

   549         User::Leave(err);

   550         }

   551 

   552     // Create thread only once

   553     if (iThread.Handle() <= 0)

   554         {

   555         err = iThread.Create(_L("VoIPDownlinkThread"),

   556                              CVoIPDownlinkThread::ThreadFunction,

   557                              KDefaultStackSize,

   558                              KMinHeapSize,

   559                              KMinHeapSize << 12, //1MB

   560                              &iShared);

   561         if (err == KErrNone)

   562             {

   563             iThread.SetPriority(EPriorityRealTime);

   564             iThread.Resume();

   565 

   566             // Open message queue for ITC back to the client

   567             if (iMsgComQueue.Handle() <= 0)

   568                 {

   569                 err = iMsgComQueue.OpenGlobal(KDnLinkComQueue);

   570                 }

   571 

   572             // Create message queue for ITC with CVoIPDownlinkThread

   573             if (iITCMsgComQueue.Handle() <= 0)

   574                 {

   575                 err = iITCMsgComQueue.CreateGlobal(KDnLinkThreadComQueue,

   576                         KVoIPMsgComQSlots);

   577                 }

   578 

   579             iVoIPServer.SetDnLinkSession(this, ETrue);

   580             iSessionType = EDnlink;

   581             }

   582         }

   583 

   584     TRACE_PRN_IF_ERR(err);

   585     TRACE_PRN_FN_EXT;

   586     }

   587 

   588 // -----------------------------------------------------------------------------

   589 // CVoIPAudioServerSession::OpenUplinkL

   590 // Method for recorder initialization.

   591 // -----------------------------------------------------------------------------

   592 //

   593 void CVoIPAudioServerSession::OpenUplinkL(const RMessage2& aMessage)

   594     {

   595     TRACE_PRN_FN_ENT;

   596 

   597     TMMFPrioritySettingsPckg pckg;

   598     aMessage.ReadL(0, pckg);

   599     iShared.iMutex.Wait();

   600     iShared.iPreference = pckg().iPref;

   601     iShared.iPriority = pckg().iPriority;

   602     iShared.iMutex.Signal();

   603 

   604     TInt err = KErrPermissionDenied;

   605 

   606     if (iVoIPServer.HasUpLinkSession())

   607         {

   608         User::Leave(err);

   609         }

   610 

   611     // Create thread only once

   612     if (iThread.Handle() <= 0)

   613         {

   614         err = iThread.Create(_L("VoIPUplinkThread"),

   615                              CVoIPUplinkThread::ThreadFunction,

   616                              KDefaultStackSize,

   617                              KMinHeapSize,

   618                              KMinHeapSize << 12, //1MB

   619                              &iShared);

   620         if (err == KErrNone)

   621             {

   622             iThread.SetPriority(EPriorityRealTime);

   623             iThread.Resume();

   624 

   625             // Create message queues

   626             if (iMsgComQueue.Handle() <= 0)

   627                 {

   628                 err = iMsgComQueue.OpenGlobal(KUpLinkComQueue);

   629                 }

   630 

   631             // Create message queue for ITC with CVoIPDownlinkThread

   632             if (iITCMsgComQueue.Handle() <= 0)

   633                 {

   634                 err = iITCMsgComQueue.CreateGlobal(KUpLinkThreadComQueue,

   635                         KVoIPMsgComQSlots);

   636                 }

   637 

   638             iVoIPServer.SetUpLinkSession(this, ETrue);

   639             iSessionType = EUplink;

   640             }

   641         }

   642 

   643     TRACE_PRN_IF_ERR(err);

   644     TRACE_PRN_FN_EXT;

   645     }

   646 

   647 // -----------------------------------------------------------------------------

   648 // CVoIPAudioServerSession::SetFormat

   649 //

   650 // -----------------------------------------------------------------------------

   651 //

   652 void CVoIPAudioServerSession::SetFormatL(const RMessage2& aMessage)

   653     {

   654     TPckgBuf<TUint32> pckg;

   655     aMessage.ReadL(0, pckg);

   656     iShared.iMutex.Wait();

   657     iShared.iCodecSettings.iFourCC = pckg();

   658     iShared.iMutex.Signal();

   659     }

   660 

   661 // -----------------------------------------------------------------------------

   662 // CVoIPAudioServerSession::StartDownlink

   663 // Call the thread to initialize downlink stream

   664 // -----------------------------------------------------------------------------

   665 //

   666 void CVoIPAudioServerSession::StartDownlink()

   667     {

   668     SendCmdToThread(ECmdStartDownlink);

   669     }

   670 

   671 // -----------------------------------------------------------------------------

   672 // CVoIPAudioServerSession::StartUplink

   673 // Call the thread to initialize uplink stream

   674 // -----------------------------------------------------------------------------

   675 //

   676 void CVoIPAudioServerSession::StartUplink()

   677     {

   678     SendCmdToThread(ECmdStartUplink);

   679     }

   680 

   681 // -----------------------------------------------------------------------------

   682 // CVoIPAudioServerSession::StopDownlink

   683 //

   684 // -----------------------------------------------------------------------------

   685 //

   686 void CVoIPAudioServerSession::StopDownlink()

   687     {

   688     SendCmdToThread(ECmdStopDownlink);

   689     }

   690 

   691 // -----------------------------------------------------------------------------

   692 // CVoIPAudioServerSession::StopUplink

   693 //

   694 // -----------------------------------------------------------------------------

   695 //

   696 void CVoIPAudioServerSession::StopUplink()

   697     {

   698     SendCmdToThread(ECmdStopUplink);

   699     }

   700 

   701 // -----------------------------------------------------------------------------

   702 // CVoIPAudioServerSession::CloseDownlink

   703 // Request downlink thread termination

   704 // -----------------------------------------------------------------------------

   705 //

   706 void CVoIPAudioServerSession::CloseDownlink()

   707     {

   708     if (iThread.Handle() > 0)

   709         {

   710         SendCmdToThread(ECmdTerminateThread);

   711         iThread.Close(); // close thread handle

   712         iVoIPServer.SetDnLinkSession(this, EFalse);

   713         NotifyClient(ECmdDownlinkThreadClosed);

   714         }

   715     }

   716 

   717 // -----------------------------------------------------------------------------

   718 // CVoIPAudioServerSession::CloseUplink

   719 //

   720 // -----------------------------------------------------------------------------

   721 //

   722 void CVoIPAudioServerSession::CloseUplink()

   723     {

   724     if (iThread.Handle() > 0)

   725         {

   726         SendCmdToThread(ECmdTerminateThread);

   727         iThread.Close(); // close thread handle

   728         iVoIPServer.SetUpLinkSession(this, EFalse);

   729         NotifyClient(ECmdUplinkThreadClosed);

   730         }

   731     }

   732 

   733 // -----------------------------------------------------------------------------

   734 // CVoIPAudioServerSession::GetMaxVolume

   735 //

   736 // -----------------------------------------------------------------------------

   737 //

   738 void CVoIPAudioServerSession::GetMaxVolumeL(const RMessage2& aMessage)

   739     {

   740     TPckgBuf<TInt> p(iMaxVolume);

   741     aMessage.WriteL(0, p);

   742 

   743     TRACE_PRN_N1(_L("VoIP->SRV-SESSION: GetMaxVolumeL->MaxVolume [%d]"),

   744             iMaxVolume);

   745     }

   746 

   747 // -----------------------------------------------------------------------------

   748 // CVoIPAudioServerSession::GetVolume

   749 //

   750 // -----------------------------------------------------------------------------

   751 //

   752 void CVoIPAudioServerSession::GetVolume(const RMessage2& aMessage)

   753     {

   754     iMessage = aMessage;

   755     iMsgQueued = ETrue;

   756     SendCmdToThread(ECmdGetVolume);

   757     }

   758 

   759 // -----------------------------------------------------------------------------

   760 // CVoIPAudioServerSession::SetVolume

   761 //

   762 // -----------------------------------------------------------------------------

   763 //

   764 void CVoIPAudioServerSession::SetVolume(const RMessage2& aMessage)

   765     {

   766     iShared.iMutex.Wait();

   767     iShared.iInt = aMessage.Int0();

   768     iShared.iMutex.Signal();

   769     SendCmdToThread(ECmdSetVolume);

   770     }

   771 

   772 // -----------------------------------------------------------------------------

   773 // CVoIPAudioServerSession::GetMaxGain

   774 //

   775 // -----------------------------------------------------------------------------

   776 //

   777 void CVoIPAudioServerSession::GetMaxGainL(const RMessage2& aMessage)

   778     {

   779     TPckgBuf<TInt> p(iMaxGain);

   780     aMessage.WriteL(0, p);

   781 

   782     TRACE_PRN_N1(_L("VoIP->SRV-SESSION: GetMaxGainL->MaxGain [%d]"), iMaxGain);

   783     }

   784 

   785 // -----------------------------------------------------------------------------

   786 // CVoIPAudioServerSession::GetGain

   787 //

   788 // -----------------------------------------------------------------------------

   789 //

   790 void CVoIPAudioServerSession::GetGain(const RMessage2& aMessage)

   791     {

   792     iMessage = aMessage;

   793     iMsgQueued = ETrue;

   794     SendCmdToThread(ECmdGetGain);

   795     }

   796 

   797 // -----------------------------------------------------------------------------

   798 // CVoIPAudioServerSession::SetGain

   799 //

   800 // -----------------------------------------------------------------------------

   801 //

   802 void CVoIPAudioServerSession::SetGain(const RMessage2& aMessage)

   803     {

   804     TInt gain = aMessage.Int0();

   805     if (gain > iMaxGain)

   806         {

   807         gain = iMaxGain;

   808         }

   809 

   810     iShared.iMutex.Wait();

   811     iShared.iInt = gain;

   812     iShared.iMutex.Signal();

   813     SendCmdToThread(ECmdSetGain);

   814     }

   815 

   816 // -----------------------------------------------------------------------------

   817 // CVoIPAudioServerSession::SetAudioDeviceL

   818 //

   819 // -----------------------------------------------------------------------------

   820 //

   821 void CVoIPAudioServerSession::SetAudioDeviceL(const RMessage2& aMessage)

   822     {

   823     TPckgBuf<TUint> pckg;

   824     aMessage.ReadL(0, pckg);

   825     iShared.iMutex.Wait();

   826     iShared.iAudioDevice = pckg();

   827     iShared.iMutex.Signal();

   828     SendCmdToThread(ECmdSetAudioDevice);

   829     }

   830 

   831 // -----------------------------------------------------------------------------

   832 // CVoIPAudioServerSession::GetAudioDevice

   833 //

   834 // -----------------------------------------------------------------------------

   835 //

   836 void CVoIPAudioServerSession::GetAudioDevice(const RMessage2& aMessage)

   837     {

   838     iMessage = aMessage;

   839     iMsgQueued = ETrue;

   840     SendCmdToThread(ECmdGetAudioDevice);

   841     }

   842 

   843 // -----------------------------------------------------------------------------

   844 // CVoIPAudioServerSession::BufferFilled

   845 //

   846 // -----------------------------------------------------------------------------

   847 //

   848 void CVoIPAudioServerSession::BufferFilledL(const RMessage2& aMessage)

   849     {

   850     //    TRACE_PRN_FN_ENT;

   851 

   852     TVoIPMsgBufPckg pckg;

   853     aMessage.ReadL(0, pckg);

   854     iShared.iMutex.Wait();

   855     iShared.iBufferSize = pckg().iInt;

   856     iShared.iSequenceNum = pckg().iUint;

   857     iShared.iMutex.Signal();

   858     SendCmdToThread(ECmdBufferFilled);

   859 

   860     //    TRACE_PRN_FN_EXT;

   861     }

   862 

   863 // -----------------------------------------------------------------------------

   864 // CVoIPAudioServerSession::BufferEmptied

   865 //

   866 // -----------------------------------------------------------------------------

   867 //

   868 void CVoIPAudioServerSession::BufferEmptiedL(const RMessage2& /*aMessage*/)

   869     {

   870     //    TRACE_PRN_FN_ENT;

   871     SendCmdToThread(ECmdBufferEmptied);

   872     //    TRACE_PRN_FN_EXT;

   873     }

   874 

   875 // -----------------------------------------------------------------------------

   876 // CVoIPAudioServerSession::SetIlbcCodecMode

   877 //

   878 // -----------------------------------------------------------------------------

   879 //

   880 void CVoIPAudioServerSession::SetIlbcCodecModeL(const RMessage2& aMessage)

   881     {

   882     TPckgBuf<CVoIPFormatIntfc::TILBCCodecMode> pckg;

   883     aMessage.ReadL(0, pckg);

   884     iShared.iMutex.Wait();

   885     iShared.iCodecSettings.iILBCCodecMode = pckg();

   886     iShared.iMutex.Signal();

   887     SendCmdToThread(ECmdSetIlbcCodecMode);

   888     }

   889 

   890 // -----------------------------------------------------------------------------

   891 // CVoIPAudioServerSession::GetIlbcCodecMode

   892 //

   893 // -----------------------------------------------------------------------------

   894 //

   895 void CVoIPAudioServerSession::GetIlbcCodecMode(const RMessage2& aMessage)

   896     {

   897     iMessage = aMessage;

   898     iMsgQueued = ETrue;

   899     SendCmdToThread(ECmdGetIlbcCodecMode);

   900     }

   901 

   902 // -----------------------------------------------------------------------------

   903 // CVoIPAudioServerSession::SetG711CodecMode

   904 //

   905 // -----------------------------------------------------------------------------

   906 //

   907 void CVoIPAudioServerSession::SetG711CodecModeL(const RMessage2& aMessage)

   908     {

   909     TPckgBuf<CVoIPFormatIntfc::TG711CodecMode> pckg;

   910     aMessage.ReadL(0, pckg);

   911     iShared.iMutex.Wait();

   912     iShared.iCodecSettings.iG711CodecMode = pckg();

   913     iShared.iMutex.Signal();

   914     SendCmdToThread(ECmdSetG711CodecMode);

   915     }

   916 

   917 // -----------------------------------------------------------------------------

   918 // CVoIPAudioServerSession::GetG711CodecMode

   919 //

   920 // -----------------------------------------------------------------------------

   921 //

   922 void CVoIPAudioServerSession::GetG711CodecMode(const RMessage2& aMessage)

   923     {

   924     iMessage = aMessage;

   925     iMsgQueued = ETrue;

   926     SendCmdToThread(ECmdGetG711CodecMode);

   927     }

   928 

   929 // -----------------------------------------------------------------------------

   930 // CVoIPAudioServerSession::GetSupportedBitratesCount

   931 //

   932 // -----------------------------------------------------------------------------

   933 //

   934 void CVoIPAudioServerSession::GetSupportedBitratesCount(

   935         const RMessage2& aMessage)

   936     {

   937     iMessage = aMessage;

   938     iMsgQueued = ETrue;

   939     SendCmdToThread(ECmdGetSupportedBitrates);

   940     }

   941 

   942 // -----------------------------------------------------------------------------

   943 // CVoIPAudioServerSession::GetSupportedBitratesL

   944 // Bitrates are already returned from the codec as a result of call to

   945 // GetSupportedBitratesCount(). Just pack them into a descriptor and return

   946 // bact to the client.

   947 // -----------------------------------------------------------------------------

   948 //

   949 void CVoIPAudioServerSession::GetSupportedBitratesL(const RMessage2& aMessage)

   950     {

   951     TRACE_PRN_FN_ENT;

   952 

   953     CBufFlat* dataCopyBuffer = CBufFlat::NewL(KArrayExpandSize);

   954     CleanupStack::PushL(dataCopyBuffer);

   955     RBufWriteStream stream;

   956     stream.Open(*dataCopyBuffer);

   957     CleanupClosePushL(stream);

   958 

   959     RArray<TUint> bitrates;

   960     iShared.iMutex.Wait();

   961     bitrates = iShared.iCodecSettings.iArrBitrates;

   962     iShared.iMutex.Signal();

   963     TInt numOfItems = bitrates.Count();

   964 

   965     for (TInt i = 0; i < numOfItems; i++)

   966         {

   967         stream.WriteUint32L(bitrates[i]);

   968 

   969         TRACE_PRN_N1(_L("VoIP->SRV-SESSION: BR: [%d]"), bitrates[i]);

   970         }

   971 

   972     aMessage.WriteL(0, dataCopyBuffer->Ptr(0));

   973 

   974     CleanupStack::PopAndDestroy(&stream);

   975     CleanupStack::PopAndDestroy(dataCopyBuffer);

   976 

   977     TRACE_PRN_FN_EXT;

   978     }

   979 

   980 // -----------------------------------------------------------------------------

   981 // CVoIPAudioServerSession::SetBitrate

   982 //

   983 // -----------------------------------------------------------------------------

   984 //

   985 void CVoIPAudioServerSession::SetBitrate(const RMessage2& aMessage)

   986     {

   987     TUint bitrate = aMessage.Int0();

   988     iShared.iMutex.Wait();

   989     iShared.iCodecSettings.iBitrate = bitrate;

   990     iShared.iMutex.Signal();

   991     SendCmdToThread(ECmdSetBitrate);

   992     }

   993 

   994 // -----------------------------------------------------------------------------

   995 // CVoIPAudioServerSession::GetBitrate

   996 //

   997 // -----------------------------------------------------------------------------

   998 //

   999 void CVoIPAudioServerSession::GetBitrate(const RMessage2& aMessage)

  1000     {

  1001     iMessage = aMessage;

  1002     iMsgQueued = ETrue;

  1003     SendCmdToThread(ECmdGetBitrate);

  1004     }

  1005 

  1006 // -----------------------------------------------------------------------------

  1007 // CVoIPAudioServerSession::FrameModeRequiredForEC

  1008 //

  1009 // -----------------------------------------------------------------------------

  1010 //

  1011 void CVoIPAudioServerSession::FrameModeRqrdForEC(const RMessage2& aMessage)

  1012     {

  1013     iMessage = aMessage;

  1014     iMsgQueued = ETrue;

  1015     SendCmdToThread(ECmdFrameModeRqrdForEC);

  1016     }

  1017 

  1018 // -----------------------------------------------------------------------------

  1019 // CVoIPAudioServerSession::SetFrameMode

  1020 //

  1021 // -----------------------------------------------------------------------------

  1022 //

  1023 void CVoIPAudioServerSession::SetFrameMode(const RMessage2& aMessage)

  1024     {

  1025     iShared.iMutex.Wait();

  1026     iShared.iCodecSettings.iFrameMode = TBool(aMessage.Int0());

  1027     iShared.iMutex.Signal();

  1028     SendCmdToThread(ECmdSetFrameMode);

  1029     }

  1030 

  1031 // -----------------------------------------------------------------------------

  1032 // CVoIPAudioServerSession::GetFrameMode

  1033 //

  1034 // -----------------------------------------------------------------------------

  1035 //

  1036 void CVoIPAudioServerSession::GetFrameMode(const RMessage2& aMessage)

  1037     {

  1038     iMessage = aMessage;

  1039     iMsgQueued = ETrue;

  1040     SendCmdToThread(ECmdGetFrameMode);

  1041     }

  1042 

  1043 // -----------------------------------------------------------------------------

  1044 // CVoIPAudioServerSession::ConcealErrorForNextBuffer

  1045 // -----------------------------------------------------------------------------

  1046 //

  1047 void CVoIPAudioServerSession::ConcealErrorForNextBuffer()

  1048     {

  1049     SendCmdToThread(ECmdConcealErrForNextBuf);

  1050     }

  1051 

  1052 // -----------------------------------------------------------------------------

  1053 // CVoIPAudioServerSession::SetVad

  1054 //

  1055 // -----------------------------------------------------------------------------

  1056 //

  1057 void CVoIPAudioServerSession::SetVad(const RMessage2& aMessage)

  1058     {

  1059     iShared.iMutex.Wait();

  1060     iShared.iCodecSettings.iVad = TBool(aMessage.Int0());

  1061     iShared.iMutex.Signal();

  1062     SendCmdToThread(ECmdSetVad);

  1063     }

  1064 

  1065 // -----------------------------------------------------------------------------

  1066 // CVoIPAudioServerSession::GetVad

  1067 //

  1068 // -----------------------------------------------------------------------------

  1069 //

  1070 void CVoIPAudioServerSession::GetVad(const RMessage2& aMessage)

  1071     {

  1072     iMessage = aMessage;

  1073     iMsgQueued = ETrue;

  1074     SendCmdToThread(ECmdGetVad);

  1075     }

  1076 

  1077 // -----------------------------------------------------------------------------

  1078 // CVoIPAudioServerSession::SetCng

  1079 //

  1080 // -----------------------------------------------------------------------------

  1081 //

  1082 void CVoIPAudioServerSession::SetCng(const RMessage2& aMessage)

  1083     {

  1084     iShared.iMutex.Wait();

  1085     iShared.iCodecSettings.iCng = TBool(aMessage.Int0());

  1086     iShared.iMutex.Signal();

  1087     SendCmdToThread(ECmdSetCng);

  1088     }

  1089 

  1090 // -----------------------------------------------------------------------------

  1091 // CVoIPAudioServerSession::GetCng

  1092 //

  1093 // -----------------------------------------------------------------------------

  1094 //

  1095 void CVoIPAudioServerSession::GetCng(const RMessage2& aMessage)

  1096     {

  1097     iMessage = aMessage;

  1098     iMsgQueued = ETrue;

  1099     SendCmdToThread(ECmdGetCng);

  1100     }

  1101 

  1102 // -----------------------------------------------------------------------------

  1103 // CVoIPAudioServerSession::SetPlc

  1104 //

  1105 // -----------------------------------------------------------------------------

  1106 //

  1107 void CVoIPAudioServerSession::SetPlc(const RMessage2& aMessage)

  1108     {

  1109     iShared.iMutex.Wait();

  1110     iShared.iCodecSettings.iPlc = TBool(aMessage.Int0());

  1111     iShared.iMutex.Signal();

  1112     SendCmdToThread(ECmdSetPlc);

  1113     }

  1114 

  1115 // -----------------------------------------------------------------------------

  1116 // CVoIPAudioServerSession::GetPlc

  1117 //

  1118 // -----------------------------------------------------------------------------

  1119 //

  1120 void CVoIPAudioServerSession::GetPlc(const RMessage2& aMessage)

  1121     {

  1122     iMessage = aMessage;

  1123     iMsgQueued = ETrue;

  1124     SendCmdToThread(ECmdGetPlc);

  1125     }

  1126 

  1127 // -----------------------------------------------------------------------------

  1128 // CVoIPAudioServerSession::BadLsfNextBuffer

  1129 //

  1130 // -----------------------------------------------------------------------------

  1131 //

  1132 void CVoIPAudioServerSession::BadLsfNextBuffer()

  1133     {

  1134     SendCmdToThread(ECmdBadLsfNextBuffer);