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: Telephony Multimedia Service

    15  *

    16  */

    17 

    18 #include <AudioPreference.h>

    19 #include "tmsutility.h"

    20 #include "tmsclientserver.h"

    21 #include "tmsshared.h"

    22 #include "ipcallstream.h"

    23 #include "callipadpt.h"

    24 

    25 using namespace TMS;

    26 

    27 // -----------------------------------------------------------------------------

    28 // CallIPAdpt::NewL

    29 // Symbian constructor.

    30 // -----------------------------------------------------------------------------

    31 //

    32 CallIPAdpt* CallIPAdpt::NewL()

    33     {

    34     CallIPAdpt* self = new (ELeave) CallIPAdpt();

    35     CleanupStack::PushL(self);

    36     self->ConstructL();

    37     CleanupStack::Pop(self);

    38     return self;

    39     }

    40 

    41 // -----------------------------------------------------------------------------

    42 // CallIPAdpt::ConstructL

    43 // 2-nd phase constructor.

    44 // -----------------------------------------------------------------------------

    45 //

    46 void CallIPAdpt::ConstructL()

    47     {

    48     TRACE_PRN_FN_ENT;

    49     iVoIPUplink = NULL;

    50     iVoIPDownlink = NULL;

    51     TRACE_PRN_FN_EXT;

    52     }

    53 

    54 // -----------------------------------------------------------------------------

    55 // CallIPAdpt::CallIPAdpt

    56 //

    57 // -----------------------------------------------------------------------------

    58 //

    59 CallIPAdpt::CallIPAdpt()

    60     {

    61     }

    62 

    63 // -----------------------------------------------------------------------------

    64 // CallIPAdpt::~CallIPAdpt

    65 //

    66 // -----------------------------------------------------------------------------

    67 //

    68 CallIPAdpt::~CallIPAdpt()

    69     {

    70     TRACE_PRN_FN_ENT;

    71 

    72     iCodecs.Reset();

    73     iCodecs.Close();

    74     iArrBitrates.Reset();

    75 

    76     delete iVoIPUplink;

    77     delete iVoIPDownlink;

    78 

    79     if (iMsgQueueUp.Handle() > 0)

    80         {

    81         iMsgQueueUp.Close();

    82         }

    83     if (iMsgQueueDn.Handle() > 0)

    84         {

    85         iMsgQueueDn.Close();

    86         }

    87 

    88     TRACE_PRN_FN_EXT;

    89     }

    90 

    91 // -----------------------------------------------------------------------------

    92 // CallIPAdpt::PostConstruct

    93 //

    94 // -----------------------------------------------------------------------------

    95 //

    96 gint CallIPAdpt::PostConstruct()

    97     {

    98     TRACE_PRN_FN_ENT;

    99     gint status(TMS_RESULT_SUCCESS);

   100     iNextStreamId = 1;

   101     iUplinkInitialized = FALSE;

   102     iDnlinkInitialized = FALSE;

   103 

   104     TRACE_PRN_FN_EXT;

   105     return status;

   106     }

   107 

   108 // -----------------------------------------------------------------------------

   109 // CallIPAdpt::CreateStream

   110 //

   111 // -----------------------------------------------------------------------------

   112 //

   113 gint CallIPAdpt::CreateStream(TMSCallType /*callType*/,

   114         TMSStreamType strmType, gint& outStrmId)

   115     {

   116     TRACE_PRN_FN_ENT;

   117     gint status(TMS_RESULT_SUCCESS);

   118     switch (strmType)

   119         {

   120         case TMS_STREAM_UPLINK:

   121             {

   122             status = TMS_RESULT_ALREADY_EXIST;

   123             if (!iUplinkInitialized)

   124                 {

   125                 iUplinkInitialized = TRUE;

   126                 iUplinkStreamId = iNextStreamId;

   127                 outStrmId = iUplinkStreamId;

   128                 iNextStreamId++;

   129                 status = TMS_RESULT_SUCCESS;

   130                 }

   131             break;

   132             }

   133         case TMS_STREAM_DOWNLINK:

   134             {

   135             status = TMS_RESULT_ALREADY_EXIST;

   136             if (!iDnlinkInitialized)

   137                 {

   138                 iDnlinkInitialized = TRUE;

   139                 iDnlinkStreamId = iNextStreamId;

   140                 outStrmId = iDnlinkStreamId;

   141                 iNextStreamId++;

   142                 status = TMS_RESULT_SUCCESS;

   143                 }

   144             break;

   145             }

   146         default:

   147             {

   148             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   149             break;

   150             }

   151         }

   152     TRACE_PRN_FN_EXT;

   153     return status;

   154     }

   155 

   156 // -----------------------------------------------------------------------------

   157 // CallIPAdpt::InitStream

   158 //

   159 // -----------------------------------------------------------------------------

   160 //

   161 gint CallIPAdpt::InitStreamL(TMSCallType /*callType*/,

   162         TMSStreamType strmType, gint strmId, TMSFormatType frmtType,

   163         const RMessage2& aMessage)

   164     {

   165     TRACE_PRN_FN_ENT;

   166     gint status(TMS_RESULT_SUCCESS);

   167 

   168     TUint32 fourCC = TOFOURCC(frmtType);

   169     if (fourCC == NULL)

   170         {

   171         return TMS_RESULT_INVALID_ARGUMENT;

   172         }

   173 

   174     switch (strmType)

   175         {

   176         case TMS_STREAM_UPLINK:

   177             {

   178             status = TMS_RESULT_DOES_NOT_EXIST;

   179             if (strmId == iUplinkStreamId)

   180                 {

   181                 SetFormat(iUplinkStreamId, fourCC);

   182                 status = OpenUplinkL(aMessage);

   183                 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);

   184                 }

   185             break;

   186             }

   187         case TMS_STREAM_DOWNLINK:

   188             {

   189             status = TMS_RESULT_DOES_NOT_EXIST;

   190             if (strmId == iDnlinkStreamId)

   191                 {

   192                 SetFormat(iDnlinkStreamId, fourCC);

   193                 status = OpenDownlinkL(aMessage);

   194                 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);

   195                 }

   196             break;

   197             }

   198         default:

   199             {

   200             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   201             break;

   202             }

   203         }

   204 

   205     TRACE_PRN_IF_ERR(status);

   206     TRACE_PRN_FN_EXT;

   207     return status;

   208     }

   209 

   210 // -----------------------------------------------------------------------------

   211 // CallIPAdpt::StartStream

   212 //

   213 // -----------------------------------------------------------------------------

   214 //

   215 gint CallIPAdpt::StartStream(TMSCallType /*callType*/, TMSStreamType strmType,

   216         gint strmId)

   217     {

   218     TRACE_PRN_FN_ENT;

   219     gint status(TMS_RESULT_INVALID_STATE);

   220     switch (strmType)

   221         {

   222         case TMS_STREAM_UPLINK:

   223             {

   224             if (strmId == iUplinkStreamId && iVoIPUplink)

   225                 {

   226                 iVoIPUplink->Start();

   227                 status = TMS_RESULT_SUCCESS;

   228                 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);

   229                 }

   230             break;

   231             }

   232         case TMS_STREAM_DOWNLINK:

   233             {

   234             if (strmId == iDnlinkStreamId && iVoIPDownlink)

   235                 {

   236                 iVoIPDownlink->Start();

   237                 status = TMS_RESULT_SUCCESS;

   238                 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);

   239                 }

   240             break;

   241             }

   242         default:

   243             {

   244             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   245             break;

   246             }

   247         }

   248     TRACE_PRN_FN_EXT;

   249     return status;

   250     }

   251 

   252 // -----------------------------------------------------------------------------

   253 // CallIPAdpt::PauseStream

   254 //

   255 // -----------------------------------------------------------------------------

   256 //

   257 gint CallIPAdpt::PauseStream(TMSCallType /*callType*/, TMSStreamType strmType,

   258         gint strmId)

   259     {

   260     TRACE_PRN_FN_ENT;

   261     gint status(TMS_RESULT_INVALID_STATE);

   262     switch (strmType)

   263         {

   264         case TMS_STREAM_UPLINK:

   265             {

   266             if (strmId == iUplinkStreamId && iVoIPUplink)

   267                 {

   268                 iVoIPUplink->Stop();

   269                 status = TMS_RESULT_SUCCESS;

   270                 NotifyClient(iUplinkStreamId, ECmdUplinkPaused, status);

   271                 }

   272             break;

   273             }

   274         case TMS_STREAM_DOWNLINK:

   275             {

   276             if (strmId == iDnlinkStreamId && iVoIPDownlink)

   277                 {

   278                 iVoIPDownlink->Stop();

   279                 status = TMS_RESULT_SUCCESS;

   280                 NotifyClient(iDnlinkStreamId, ECmdDownlinkPaused, status);

   281                 }

   282             break;

   283             }

   284         default:

   285             {

   286             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   287             break;

   288             }

   289         }

   290     TRACE_PRN_FN_EXT;

   291     return status;

   292     }

   293 

   294 // -----------------------------------------------------------------------------

   295 // CallIPAdpt::StopStream

   296 //

   297 // -----------------------------------------------------------------------------

   298 //

   299 gint CallIPAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType,

   300         gint strmId)

   301     {

   302     TRACE_PRN_FN_ENT;

   303     gint status(TMS_RESULT_INVALID_STATE);

   304 

   305     switch (strmType)

   306         {

   307         case TMS_STREAM_UPLINK:

   308             {

   309             if (strmId == iUplinkStreamId && iVoIPUplink)

   310                 {

   311                 iVoIPUplink->Stop();

   312                 status = TMS_RESULT_SUCCESS;

   313                 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);

   314                 }

   315             break;

   316             }

   317         case TMS_STREAM_DOWNLINK:

   318             {

   319             if (strmId == iDnlinkStreamId && iVoIPDownlink)

   320                 {

   321                 iVoIPDownlink->Stop();

   322                 status = TMS_RESULT_SUCCESS;

   323                 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);

   324                 }

   325             break;

   326             }

   327         default:

   328             {

   329             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   330             break;

   331             }

   332         }

   333     TRACE_PRN_FN_EXT;

   334     return status;

   335     }

   336 

   337 // -----------------------------------------------------------------------------

   338 // CallIPAdpt::DeinitStream

   339 //

   340 // -----------------------------------------------------------------------------

   341 //

   342 gint CallIPAdpt::DeinitStream(TMSCallType /*callType*/, TMSStreamType strmType,

   343         gint strmId)

   344     {

   345     TRACE_PRN_FN_ENT;

   346     gint status(TMS_RESULT_INVALID_STATE);

   347 

   348     switch (strmType)

   349         {

   350         case TMS_STREAM_UPLINK:

   351             {

   352             if (strmId == iUplinkStreamId && iVoIPUplink)

   353                 {

   354                 iVoIPUplink->Stop();

   355                 //iUplinkStreamId = -1;

   356                 iUplinkInitialized = FALSE;

   357                 status = TMS_RESULT_SUCCESS;

   358                 NotifyClient(iUplinkStreamId, ECmdDownlinkDeInitComplete,

   359                         status);

   360                 }

   361             break;

   362             }

   363         case TMS_STREAM_DOWNLINK:

   364             {

   365             if (strmId == iDnlinkStreamId && iVoIPDownlink)

   366                 {

   367                 iVoIPDownlink->Stop();

   368                 //iDnlinkStreamId = -1;

   369                 iDnlinkInitialized = FALSE;

   370                 status = TMS_RESULT_SUCCESS;

   371                 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete,

   372                         status);

   373                 }

   374             break;

   375             }

   376         default:

   377             {

   378             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   379             break;

   380             }

   381         }

   382 

   383     TRACE_PRN_FN_EXT;

   384     return status;

   385     }

   386 

   387 // -----------------------------------------------------------------------------

   388 // CallIPAdpt::DeleteStream

   389 //

   390 // -----------------------------------------------------------------------------

   391 //

   392 gint CallIPAdpt::DeleteStream(TMSCallType /*callType*/,

   393         TMSStreamType strmType, gint strmId)

   394     {

   395     TRACE_PRN_FN_ENT;

   396     gint status(TMS_RESULT_SUCCESS);

   397     switch (strmType)

   398         {

   399         case TMS_STREAM_UPLINK:

   400             {

   401             // This is additional error checking

   402             if (strmId == iUplinkStreamId)

   403                 {

   404                 iUplinkStreamId = -1;

   405                 iUplinkInitialized = FALSE;

   406                 }

   407             break;

   408             }

   409         case TMS_STREAM_DOWNLINK:

   410             {

   411             // This is additional error checking

   412             if (strmId == iDnlinkStreamId)

   413                 {

   414                 iDnlinkStreamId = -1;

   415                 iDnlinkInitialized = FALSE;

   416                 }

   417             break;

   418             }

   419         default:

   420             {

   421             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   422             break;

   423             }

   424         }

   425     TRACE_PRN_FN_EXT;

   426     return status;

   427     }

   428 

   429 // -----------------------------------------------------------------------------

   430 // CallIPAdpt::DataXferBufferEmptied

   431 //

   432 // -----------------------------------------------------------------------------

   433 //

   434 gint CallIPAdpt::DataXferBufferEmptied(TMSCallType /*callType*/,

   435         TMSStreamType strmType, gint strmId)

   436     {

   437     TRACE_PRN_FN_ENT;

   438     gint status(TMS_RESULT_SUCCESS);

   439     switch (strmType)

   440         {

   441         case TMS_STREAM_UPLINK:

   442             {

   443             if (strmId == iUplinkStreamId)

   444                 {

   445                 TRAP(status, BufferEmptiedL());

   446                 }

   447             break;

   448             }

   449         case TMS_STREAM_DOWNLINK:

   450             status = TMS_RESULT_ILLEGAL_OPERATION;

   451             break;

   452         default:

   453             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   454             break;

   455         }

   456     TRACE_PRN_FN_EXT;

   457     return status;

   458     }

   459 

   460 // -----------------------------------------------------------------------------

   461 // CallIPAdpt::DataXferBufferFilled

   462 //

   463 // -----------------------------------------------------------------------------

   464 //

   465 gint CallIPAdpt::DataXferBufferFilled(TMSCallType /*callType*/,

   466         TMSStreamType strmType, gint strmId, guint datasize)

   467     {

   468     TRACE_PRN_FN_ENT;

   469     gint status(TMS_RESULT_SUCCESS);

   470     switch (strmType)

   471         {

   472         case TMS_STREAM_DOWNLINK:

   473             if (strmId == iDnlinkStreamId)

   474                 {

   475                 TRAP(status, BufferFilledL(datasize));

   476                 }

   477             break;

   478         case TMS_STREAM_UPLINK:

   479             status = TMS_RESULT_ILLEGAL_OPERATION;

   480             break;

   481         default:

   482             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   483             break;

   484         }

   485     TRACE_PRN_FN_EXT;

   486     return status;

   487     }

   488 

   489 // -----------------------------------------------------------------------------

   490 // CallIPAdpt::GetDataXferBufferHndl

   491 //

   492 // -----------------------------------------------------------------------------

   493 //

   494 gint CallIPAdpt::GetDataXferBufferHndl(const TMSCallType /*callType*/,

   495         const TMSStreamType strmType, const gint strmId, const guint32 key,

   496         RChunk& chunk)

   497     {

   498     TRACE_PRN_FN_ENT;

   499     gint status(TMS_RESULT_SUCCESS);

   500     switch (strmType)

   501         {

   502         case TMS_STREAM_DOWNLINK:

   503             {

   504             if (strmId == iDnlinkStreamId)

   505                 {

   506                 TRAP(status, GetDataXferChunkHndl(strmType, key, chunk));

   507                 }

   508             break;

   509             }

   510         case TMS_STREAM_UPLINK:

   511             {

   512             if (strmId == iUplinkStreamId)

   513                 {

   514                 TRAP(status, GetDataXferChunkHndl(strmType, key, chunk));

   515                 }

   516             break;

   517             }

   518         default:

   519             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   520             break;

   521         }

   522     TRACE_PRN_FN_EXT;

   523     return status;

   524     }

   525 

   526 // -----------------------------------------------------------------------------

   527 // CallIPAdpt::GetMaxVolume

   528 //

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

   530 //

   531 gint CallIPAdpt::GetMaxVolume(guint& volume)

   532     {

   533     TRACE_PRN_FN_ENT;

   534     gint status(TMS_RESULT_INVALID_STATE);

   535 

   536     if (iDnlinkInitialized && iVoIPDownlink)

   537         {

   538         status = iVoIPDownlink->GetMaxVolume(volume);

   539         iMaxVolume = volume;

   540         TRACE_PRN_N1(_L("TMS->CallIPAdpt: GetMaxVolume [%d]"), iMaxVolume);

   541         }

   542 

   543     TRACE_PRN_FN_EXT;

   544     return status;

   545     }

   546 

   547 // -----------------------------------------------------------------------------

   548 // CallIPAdpt::SetVolume

   549 //

   550 // -----------------------------------------------------------------------------

   551 //

   552 gint CallIPAdpt::SetVolume(const guint volume)

   553     {

   554     TRACE_PRN_FN_ENT;

   555     gint status(TMS_RESULT_INVALID_STATE);

   556     if (iDnlinkInitialized && iVoIPDownlink)

   557         {

   558         status = iVoIPDownlink->SetVolume(volume);

   559         NotifyClient(iDnlinkStreamId, ECmdSetVolume, status);

   560         }

   561     TRACE_PRN_FN_EXT;

   562     return status;

   563     }

   564 

   565 // -----------------------------------------------------------------------------

   566 // CallIPAdpt::GetVolume

   567 //

   568 // -----------------------------------------------------------------------------

   569 //

   570 gint CallIPAdpt::GetVolume(guint& volume)

   571     {

   572     TRACE_PRN_FN_ENT;

   573     gint status(TMS_RESULT_INVALID_STATE);

   574     if (iDnlinkInitialized && iVoIPDownlink)

   575         {

   576         status = iVoIPDownlink->GetVolume(volume);

   577         }

   578     TRACE_PRN_FN_EXT;

   579     return status;

   580     }

   581 

   582 // -----------------------------------------------------------------------------

   583 // CallIPAdpt::GetMaxGain

   584 //

   585 // -----------------------------------------------------------------------------

   586 //

   587 gint CallIPAdpt::GetMaxGain(guint& gain)

   588     {

   589     TRACE_PRN_FN_ENT;

   590     gint status(TMS_RESULT_INVALID_STATE);

   591     if (iUplinkInitialized && iVoIPUplink)

   592         {

   593         status = iVoIPUplink->GetMaxGain(gain);

   594         iMaxGain = gain;

   595         TRACE_PRN_N1(_L("TMS->CallIPAdpt::GetMaxGain [%d]"), iMaxGain);

   596         }

   597     TRACE_PRN_FN_EXT;

   598     return status;

   599     }

   600 

   601 // -----------------------------------------------------------------------------

   602 // CallIPAdpt::SetGain

   603 //

   604 // -----------------------------------------------------------------------------

   605 //

   606 gint CallIPAdpt::SetGain(const guint gain)

   607     {

   608     TRACE_PRN_FN_ENT;

   609     gint status(TMS_RESULT_INVALID_STATE);

   610     if (iUplinkInitialized && iVoIPUplink)

   611         {

   612         status = iVoIPUplink->SetGain(gain);

   613         NotifyClient(iUplinkStreamId, ECmdSetGain, status);

   614         }

   615     TRACE_PRN_FN_EXT;

   616     return status;

   617     }

   618 

   619 // -----------------------------------------------------------------------------

   620 // CallIPAdpt::GetGain

   621 //

   622 // -----------------------------------------------------------------------------

   623 //

   624 gint CallIPAdpt::GetGain(guint& gain)

   625     {

   626     TRACE_PRN_FN_ENT;

   627     gint status(TMS_RESULT_INVALID_STATE);

   628     if (iUplinkInitialized && iVoIPUplink)

   629         {

   630         status = iVoIPUplink->GetGain(gain);

   631         }

   632     TRACE_PRN_FN_EXT;

   633     return status;

   634     }

   635 

   636 // -----------------------------------------------------------------------------

   637 // CallIPAdpt::GetGlobalMaxVolume

   638 //

   639 // -----------------------------------------------------------------------------

   640 //

   641 gint CallIPAdpt::GetGlobalMaxVolume(guint& volume)

   642     {

   643     TRACE_PRN_FN_ENT;

   644     gint status(TMS_RESULT_INVALID_STATE);

   645     if (iDnlinkInitialized && iVoIPDownlink)

   646         {

   647         status = iVoIPDownlink->GetMaxVolume(volume);

   648         iMaxVolume = volume;

   649         TRACE_PRN_N1(_L("TMS->CallIPAdpt: GetMaxVolume [%d]"), iMaxVolume);

   650         }

   651     TRACE_PRN_FN_EXT;

   652     return status;

   653     }

   654 

   655 // -----------------------------------------------------------------------------

   656 // CallIPAdpt::SetGlobalVolume

   657 //

   658 // -----------------------------------------------------------------------------

   659 //

   660 gint CallIPAdpt::SetGlobalVolume(const guint volume)

   661     {

   662     TRACE_PRN_FN_ENT;

   663     gint status(TMS_RESULT_INVALID_STATE);

   664     if (iDnlinkInitialized && iVoIPDownlink)

   665         {

   666         status = iVoIPDownlink->SetVolume(volume);

   667         }

   668     TRACE_PRN_FN_EXT;

   669     return status;

   670     }

   671 

   672 // -----------------------------------------------------------------------------

   673 // CallIPAdpt::GetGlobalVolume

   674 //

   675 // -----------------------------------------------------------------------------

   676 //

   677 gint CallIPAdpt::GetGlobalVolume(guint& volume)

   678     {

   679     TRACE_PRN_FN_ENT;

   680     gint status(TMS_RESULT_INVALID_STATE);

   681     if (iDnlinkInitialized && iVoIPDownlink)

   682         {

   683         status = iVoIPDownlink->GetVolume(volume);

   684         }

   685     TRACE_PRN_FN_EXT;

   686     return status;

   687     }

   688 

   689 // -----------------------------------------------------------------------------

   690 // CallIPAdpt::GetGlobalMaxGain

   691 //

   692 // -----------------------------------------------------------------------------

   693 //

   694 gint CallIPAdpt::GetGlobalMaxGain(guint& gain)

   695     {

   696     TRACE_PRN_FN_ENT;

   697     gint status(TMS_RESULT_INVALID_STATE);

   698     if (iUplinkInitialized && iVoIPUplink)

   699         {

   700         status = iVoIPUplink->GetMaxGain(gain);

   701         iMaxGain = gain;

   702         TRACE_PRN_N1(_L("TMS->CallIPAdpt::GetMaxGain [%d]"), iMaxGain);

   703         }

   704     TRACE_PRN_FN_EXT;

   705     return status;

   706     }

   707 

   708 // -----------------------------------------------------------------------------

   709 // CallIPAdpt::SetGlobalGain

   710 //

   711 // -----------------------------------------------------------------------------

   712 //

   713 gint CallIPAdpt::SetGlobalGain(const guint gain)

   714     {

   715     TRACE_PRN_FN_ENT;

   716     gint status(TMS_RESULT_INVALID_STATE);

   717     if (iUplinkInitialized && iVoIPUplink)

   718         {

   719         status = iVoIPUplink->SetGain(gain);

   720         }

   721     TRACE_PRN_FN_EXT;

   722     return status;

   723     }

   724 

   725 // -----------------------------------------------------------------------------

   726 // CallIPAdpt::GetGlobalGain

   727 //

   728 // -----------------------------------------------------------------------------

   729 //

   730 gint CallIPAdpt::GetGlobalGain(guint& gain)

   731     {

   732     TRACE_PRN_FN_ENT;

   733     gint status(TMS_RESULT_INVALID_STATE);

   734     if (iUplinkInitialized && iVoIPUplink)

   735         {

   736         status = iVoIPUplink->GetGain(gain);

   737         }

   738     TRACE_PRN_FN_EXT;

   739     return status;

   740     }

   741 

   742 // -----------------------------------------------------------------------------

   743 // CallIPAdpt::GetCodecMode

   744 //

   745 // -----------------------------------------------------------------------------

   746 //

   747 gint CallIPAdpt::GetCodecMode(const TMSFormatType fmttype,

   748         const TMSStreamType strmtype, gint& mode)

   749     {

   750     TRACE_PRN_FN_ENT;

   751     gint status(TMS_RESULT_SUCCESS);

   752     switch (fmttype)

   753         {

   754         case TMS_FORMAT_ILBC:

   755             status = GetIlbcCodecMode(mode, strmtype);

   756             break;

   757         case TMS_FORMAT_G711:

   758             status = GetG711CodecMode(mode, strmtype);

   759             break;

   760         default:

   761             status = TMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED;

   762             break;

   763         }

   764     TRACE_PRN_FN_EXT;

   765     return status;

   766     }

   767 

   768 // -----------------------------------------------------------------------------

   769 // CallIPAdpt::SetCodecMode

   770 //

   771 // -----------------------------------------------------------------------------

   772 //

   773 gint CallIPAdpt::SetCodecMode(const TMSFormatType fmttype,

   774         const TMSStreamType strmtype, const gint mode)

   775     {

   776     TRACE_PRN_FN_ENT;

   777     gint status(TMS_RESULT_SUCCESS);

   778     switch (fmttype)

   779         {

   780         case TMS_FORMAT_ILBC:

   781             status = SetIlbcCodecMode(mode, strmtype);

   782             break;

   783         case TMS_FORMAT_G711:

   784             status = SetG711CodecMode(mode, strmtype);

   785             break;

   786         default:

   787             status = TMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED;

   788             break;

   789         }

   790     TRACE_PRN_FN_EXT;

   791     return status;

   792     }

   793 

   794 // -----------------------------------------------------------------------------

   795 // CallIPAdpt::GetSupportedBitRatesCount

   796 //

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

   798 //

   799 gint CallIPAdpt::GetSupportedBitRatesCount(guint& count)

   800     {

   801     TRACE_PRN_FN_ENT;

   802     gint status(TMS_RESULT_INVALID_STATE);

   803     if (iVoIPUplink)

   804         {

   805         status = iVoIPUplink->GetSupportedBitrates(iArrBitrates);

   806         count = iArrBitrates.Count();

   807         }

   808     TRACE_PRN_FN_EXT;

   809     return status;

   810     }

   811 

   812 // -----------------------------------------------------------------------------

   813 // CallIPAdpt::GetSupportedBitRates

   814 //

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

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

   817 // back to the client.

   818 // -----------------------------------------------------------------------------

   819 //

   820 gint CallIPAdpt::GetSupportedBitRates(CBufFlat*& brbuffer)

   821     {

   822     TRAPD(status, GetSupportedBitRatesL(brbuffer));

   823     return status;

   824     }

   825 

   826 // -----------------------------------------------------------------------------

   827 // CallIPAdpt::GetSupportedBitRatesL

   828 //

   829 // GetSupportedBitRates implementation which can leave.

   830 // -----------------------------------------------------------------------------

   831 //

   832 void CallIPAdpt::GetSupportedBitRatesL(CBufFlat*& brbuffer)

   833     {

   834     TRACE_PRN_FN_ENT;

   835     RBufWriteStream stream;

   836     stream.Open(*brbuffer);

   837     CleanupClosePushL(stream);

   838     guint numOfItems = iArrBitrates.Count();

   839 

   840     for (guint i = 0; i < numOfItems; i++)

   841         {

   842         stream.WriteUint32L(iArrBitrates[i]);

   843         //TRACE_PRN_N1(_L("TMS->CallIPAdpt: BR: [%d]"), iArrBitrates[i]);

   844         }

   845 

   846     CleanupStack::PopAndDestroy(&stream);

   847     TRACE_PRN_FN_EXT;

   848     }

   849 

   850 // -----------------------------------------------------------------------------

   851 // CallIPAdpt::GetBitRate

   852 //

   853 // -----------------------------------------------------------------------------

   854 //

   855 gint CallIPAdpt::GetBitRate(guint& bitrate)

   856     {

   857     TRACE_PRN_FN_ENT;

   858     gint status(TMS_RESULT_INVALID_STATE);

   859     if (iVoIPUplink)

   860         {

   861         status = iVoIPUplink->GetBitrate(bitrate);

   862         }

   863     TRACE_PRN_FN_EXT;

   864     return status;

   865     }

   866 

   867 // -----------------------------------------------------------------------------

   868 // CallIPAdpt::SetBitRate

   869 //

   870 // -----------------------------------------------------------------------------

   871 //

   872 gint CallIPAdpt::SetBitRate(const guint bitrate)

   873     {

   874     TRACE_PRN_FN_ENT;

   875     gint status(TMS_RESULT_INVALID_STATE);

   876     if (iVoIPUplink)

   877         {

   878         status = iVoIPUplink->SetBitrate(bitrate);

   879         }

   880     TRACE_PRN_FN_EXT;

   881     return status;

   882     }

   883 

   884 // -----------------------------------------------------------------------------

   885 // CallIPAdpt::GetVAD

   886 //

   887 // -----------------------------------------------------------------------------

   888 //

   889 gint CallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad)

   890     {

   891     TRACE_PRN_FN_ENT;

   892     gint status(TMS_RESULT_INVALID_STATE);

   893     if (iVoIPUplink)

   894         {

   895         status = iVoIPUplink->GetVad(fmttype, vad);

   896         }

   897     TRACE_PRN_FN_EXT;

   898     return status;

   899     }

   900 

   901 // -----------------------------------------------------------------------------

   902 // CallIPAdpt::SetVAD

   903 //

   904 // -----------------------------------------------------------------------------

   905 //

   906 gint CallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad)

   907     {

   908     TRACE_PRN_FN_ENT;

   909     gint status(TMS_RESULT_INVALID_STATE);

   910     if (iVoIPUplink)

   911         {

   912         status = iVoIPUplink->SetVad(fmttype, vad);

   913         }

   914     TRACE_PRN_FN_EXT;

   915     return status;

   916     }

   917 

   918 // -----------------------------------------------------------------------------

   919 // CallIPAdpt::GetCNG

   920 //

   921 // -----------------------------------------------------------------------------

   922 //

   923 gint CallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng)

   924     {

   925     TRACE_PRN_FN_ENT;

   926     gint status(TMS_RESULT_INVALID_STATE);

   927     if (iVoIPDownlink)

   928         {

   929         status = iVoIPDownlink->GetCng(fmttype, cng);

   930         }

   931     TRACE_PRN_FN_EXT;

   932     return status;

   933     }

   934 

   935 // -----------------------------------------------------------------------------

   936 // CallIPAdpt::SetCNG

   937 //

   938 // -----------------------------------------------------------------------------

   939 //

   940 gint CallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng)

   941     {

   942     TRACE_PRN_FN_ENT;

   943     gint status(TMS_RESULT_INVALID_STATE);

   944     if (iVoIPDownlink)

   945         {

   946         status = iVoIPDownlink->SetCng(fmttype, cng);

   947         }

   948     TRACE_PRN_FN_EXT;

   949     return status;

   950     }

   951 

   952 // -----------------------------------------------------------------------------

   953 // CallIPAdpt::GetPlc

   954 //

   955 // -----------------------------------------------------------------------------

   956 //

   957 gint CallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc)

   958     {

   959     TRACE_PRN_FN_ENT;

   960     gint status(TMS_RESULT_INVALID_STATE);

   961     if (iVoIPDownlink)

   962         {

   963         status = iVoIPDownlink->GetPlc(fmttype, plc);

   964         }

   965     TRACE_PRN_FN_EXT;

   966     return status;

   967     }

   968 

   969 // -----------------------------------------------------------------------------

   970 // CallIPAdpt::SetPlc

   971 //

   972 // -----------------------------------------------------------------------------

   973 //

   974 gint CallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc)

   975     {

   976     TRACE_PRN_FN_ENT;

   977     gint status(TMS_RESULT_INVALID_STATE);

   978     if (iVoIPDownlink)

   979         {

   980         status = iVoIPDownlink->SetPlc(fmttype, plc);

   981         }

   982     TRACE_PRN_FN_EXT;

   983     return status;

   984     }

   985 

   986 // -----------------------------------------------------------------------------

   987 // CallIPAdpt::OpenDownlinkL

   988 // Method for player initialization.

   989 // -----------------------------------------------------------------------------

   990 //

   991 gint CallIPAdpt::OpenDownlinkL(const RMessage2& aMessage)

   992     {

   993     TRACE_PRN_FN_ENT;

   994     gint status(TMS_RESULT_SUCCESS);

   995 

   996     // Ensure clients have MultimediaDD capability to use this priority/pref

   997     // TODO: TMS must monitor for emergency call now

   998     iPriority.iPref = TMdaPriorityPreference(KAudioPrefVoipAudioDownlink);

   999     iPriority.iPriority = TMdaPriority(KAudioPriorityVoipAudioDownlink);

  1000 

  1001     if (!iVoIPDownlink)

  1002         {

  1003         iVoIPDownlink = TMSVoIPDownlink::NewL(iDnFourCC, iPriority);

  1004         }

  1005 

  1006     if (iVoIPDownlink)

  1007         {

  1008         // Open message queue for handling server notifications to the client

  1009         if (iMsgQueueDn.Handle() <= 0)

  1010             {

  1011             // Second argument in TMSCallProxy::InitStream

  1012             status = iMsgQueueDn.Open(aMessage, 1);

  1013             }

  1014 

  1015         if (status == TMS_RESULT_SUCCESS)

  1016             {

  1017             // For transfer data buffer processing

  1018             iVoIPDownlink->SetMsgQueue(iMsgQueueDn);

  1019             }

  1020         }

  1021 

  1022     TRACE_PRN_IF_ERR(status);

  1023     TRACE_PRN_FN_EXT;

  1024     return status;

  1025     }

  1026 

  1027 // -----------------------------------------------------------------------------

  1028 // CallIPAdpt::OpenUplinkL

  1029 // Method for recorder initialization.

  1030 // -----------------------------------------------------------------------------

  1031 //

  1032 gint CallIPAdpt::OpenUplinkL(const RMessage2& aMessage)

  1033     {

  1034     TRACE_PRN_FN_ENT;

  1035     gint status(TMS_RESULT_SUCCESS);

  1036 

  1037     // Ensure clients have MultimediaDD capability to use this priority/pref

  1038     iPriority.iPref = TMdaPriorityPreference(KAudioPrefVoipAudioUplink);

  1039     iPriority.iPriority = TMdaPriority(KAudioPriorityVoipAudioUplink);

  1040 

  1041     if (!iVoIPUplink)

  1042         {

  1043         iVoIPUplink = TMSVoIPUplink::NewL(iUpFourCC, iPriority);

  1044         }

  1045 

  1046     if (iVoIPUplink)

  1047         {

  1048         // Open message queue for handling server notifications to the client

  1049         if (iMsgQueueUp.Handle() <= 0)

  1050             {

  1051             // Second argument in TMSCallProxy::InitStream

  1052             status = iMsgQueueUp.Open(aMessage, 1);

  1053             }

  1054 

  1055         if (status == TMS_RESULT_SUCCESS)

  1056             {

  1057             // For transfer data buffer processing

  1058             iVoIPUplink->SetMsgQueue(iMsgQueueUp);

  1059             }

  1060         }

  1061 

  1062     TRACE_PRN_IF_ERR(status);

  1063     TRACE_PRN_FN_EXT;

  1064     return status;

  1065     }

  1066 

  1067 // -----------------------------------------------------------------------------

  1068 // CallIPAdpt::SetFormat

  1069 //

  1070 // -----------------------------------------------------------------------------

  1071 //

  1072 void CallIPAdpt::SetFormat(const gint strmId, const TUint32 aFormat)

  1073     {

  1074     if (strmId == iUplinkStreamId)

  1075         {

  1076         iUpFourCC = aFormat;

  1077         }

  1078     else if (strmId == iDnlinkStreamId)

  1079         {

  1080         iDnFourCC = aFormat;

  1081         }

  1082     }

  1083 

  1084 // -----------------------------------------------------------------------------

  1085 // CallIPAdpt::BufferFilled

  1086 //

  1087 // -----------------------------------------------------------------------------

  1088 //

  1089 void CallIPAdpt::BufferFilledL(TUint dataSize)

  1090     {

  1091     if (iVoIPDownlink)

  1092         {

  1093         iVoIPDownlink->BufferFilled(dataSize);

  1094         }

  1095     }

  1096 

  1097 // -----------------------------------------------------------------------------

  1098 // CallIPAdpt::BufferEmptied

  1099 //

  1100 // -----------------------------------------------------------------------------

  1101 //

  1102 void CallIPAdpt::BufferEmptiedL()

  1103     {

  1104     if (iVoIPUplink)

  1105         {

  1106         iVoIPUplink->BufferEmptied();

  1107         }

  1108     }

  1109 

  1110 // ----------------------------------------------------------------------------

  1111 // CallIPAdpt::GetDataXferChunkHndl

  1112 //

  1113 // ----------------------------------------------------------------------------

  1114 //

  1115 gint CallIPAdpt::GetDataXferChunkHndl(const TMSStreamType strmType,

  1116         const TUint32 key, RChunk& chunk)

  1117     {

  1118     TRACE_PRN_FN_ENT;

  1119 

  1120     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

  1121     switch (strmType)

  1122         {

  1123         case TMS_STREAM_DOWNLINK:

  1124             {

  1125             if (iVoIPDownlink)

  1126                 {

  1127                 status = iVoIPDownlink->GetDataXferChunkHndl(key, chunk);

  1128                 }

  1129             break;

  1130             }

  1131         case TMS_STREAM_UPLINK:

  1132             {

  1133             if (iVoIPUplink)

  1134                 {