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 // TMSCallIPAdpt::NewL

    29 // Symbian constructor.

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

    31 //

    32 TMSCallIPAdpt* TMSCallIPAdpt::NewL()

    33     {

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

    35     CleanupStack::PushL(self);

    36     self->ConstructL();

    37     CleanupStack::Pop(self);

    38     return self;

    39     }

    40 

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

    42 // TMSCallIPAdpt::ConstructL

    43 // 2-nd phase constructor.

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

    45 //

    46 void TMSCallIPAdpt::ConstructL()

    47     {

    48     TRACE_PRN_FN_ENT;

    49     iIPUplink = NULL;

    50     iIPDownlink = NULL;

    51     iDTMFDnlinkPlayer = NULL;

    52     iDTMFUplinkPlayer = NULL;

    53     iDTMFNotifier = NULL;

    54     TRACE_PRN_FN_EXT;

    55     }

    56 

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

    58 // TMSCallIPAdpt::TMSCallIPAdpt

    59 //

    60 // -----------------------------------------------------------------------------

    61 //

    62 TMSCallIPAdpt::TMSCallIPAdpt()

    63     {

    64     }

    65 

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

    67 // TMSCallIPAdpt::~TMSCallIPAdpt

    68 //

    69 // -----------------------------------------------------------------------------

    70 //

    71 TMSCallIPAdpt::~TMSCallIPAdpt()

    72     {

    73     TRACE_PRN_FN_ENT;

    74 

    75     iCodecs.Reset();

    76     iCodecs.Close();

    77     iArrBitrates.Reset();

    78     delete iDTMFUplinkPlayer;

    79     delete iDTMFDnlinkPlayer;

    80     delete iDTMFNotifier;

    81     delete iIPUplink;

    82     delete iIPDownlink;

    83 

    84     if (iMsgQueueUp.Handle() > 0)

    85         {

    86         iMsgQueueUp.Close();

    87         }

    88     if (iMsgQueueDn.Handle() > 0)

    89         {

    90         iMsgQueueDn.Close();

    91         }

    92 

    93     TRACE_PRN_FN_EXT;

    94     }

    95 

    96 // -----------------------------------------------------------------------------

    97 // TMSCallIPAdpt::PostConstruct

    98 //

    99 // -----------------------------------------------------------------------------

   100 //

   101 gint TMSCallIPAdpt::PostConstruct()

   102     {

   103     TRACE_PRN_FN_ENT;

   104     gint status(TMS_RESULT_SUCCESS);

   105     iNextStreamId = 1;

   106     iUplinkInitialized = FALSE;

   107     iDnlinkInitialized = FALSE;

   108 

   109     TRACE_PRN_FN_EXT;

   110     return status;

   111     }

   112 

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

   114 // TMSCallIPAdpt::CreateStream

   115 //

   116 // -----------------------------------------------------------------------------

   117 //

   118 gint TMSCallIPAdpt::CreateStream(TMSCallType /*callType*/,

   119         TMSStreamType strmType, gint& outStrmId)

   120     {

   121     TRACE_PRN_FN_ENT;

   122     gint status(TMS_RESULT_SUCCESS);

   123     switch (strmType)

   124         {

   125         case TMS_STREAM_UPLINK:

   126             {

   127             status = TMS_RESULT_ALREADY_EXIST;

   128             if (!iUplinkInitialized)

   129                 {

   130                 iUplinkInitialized = TRUE;

   131                 iUplinkStreamId = iNextStreamId;

   132                 outStrmId = iUplinkStreamId;

   133                 iNextStreamId++;

   134                 status = TMS_RESULT_SUCCESS;

   135                 }

   136             break;

   137             }

   138         case TMS_STREAM_DOWNLINK:

   139             {

   140             status = TMS_RESULT_ALREADY_EXIST;

   141             if (!iDnlinkInitialized)

   142                 {

   143                 iDnlinkInitialized = TRUE;

   144                 iDnlinkStreamId = iNextStreamId;

   145                 outStrmId = iDnlinkStreamId;

   146                 iNextStreamId++;

   147                 status = TMS_RESULT_SUCCESS;

   148                 }

   149             break;

   150             }

   151         default:

   152             {

   153             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   154             break;

   155             }

   156         }

   157     TRACE_PRN_FN_EXT;

   158     return status;

   159     }

   160 

   161 // -----------------------------------------------------------------------------

   162 // TMSCallIPAdpt::InitStream

   163 //

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

   165 //

   166 gint TMSCallIPAdpt::InitStreamL(TMSCallType /*callType*/,

   167         TMSStreamType strmType, gint strmId, TMSFormatType frmtType,

   168         const RMessage2& aMessage)

   169     {

   170     TRACE_PRN_FN_ENT;

   171     gint status(TMS_RESULT_SUCCESS);

   172 

   173     TUint32 fourCC = TOFOURCC(frmtType);

   174     if (fourCC == NULL)

   175         {

   176         return TMS_RESULT_INVALID_ARGUMENT;

   177         }

   178 

   179     switch (strmType)

   180         {

   181         case TMS_STREAM_UPLINK:

   182             {

   183             status = TMS_RESULT_DOES_NOT_EXIST;

   184             if (strmId == iUplinkStreamId)

   185                 {

   186                 SetFormat(iUplinkStreamId, fourCC);

   187                 status = OpenUplinkL(aMessage);

   188 

   189                 iDTMFUplinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,

   190                         KAudioPrefUnknownVoipAudioUplink,

   191                         KAudioPriorityUnknownVoipAudioUplink);

   192 

   193                 if(!iDTMFNotifier)

   194                     {

   195                     iDTMFNotifier = TMSDtmfNotifier::NewL();

   196                     }

   197 

   198                 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);

   199                 }

   200             break;

   201             }

   202         case TMS_STREAM_DOWNLINK:

   203             {

   204             status = TMS_RESULT_DOES_NOT_EXIST;

   205             if (strmId == iDnlinkStreamId)

   206                 {

   207                 SetFormat(iDnlinkStreamId, fourCC);

   208                 status = OpenDownlinkL(aMessage);

   209 

   210                 iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,

   211                         KAudioPrefUnknownVoipAudioDownlink,

   212                         KAudioPriorityUnknownVoipAudioDownlink);

   213 

   214                 if(!iDTMFNotifier)

   215                     {

   216                     iDTMFNotifier = TMSDtmfNotifier::NewL();

   217                     }

   218 

   219                 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);

   220                 }

   221             break;

   222             }

   223         default:

   224             {

   225             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   226             break;

   227             }

   228         }

   229 

   230     TRACE_PRN_IF_ERR(status);

   231     TRACE_PRN_FN_EXT;

   232     return status;

   233     }

   234 

   235 // -----------------------------------------------------------------------------

   236 // TMSCallIPAdpt::StartStream

   237 //

   238 // -----------------------------------------------------------------------------

   239 //

   240 gint TMSCallIPAdpt::StartStream(TMSCallType /*callType*/,

   241         TMSStreamType strmType, gint strmId)

   242     {

   243     TRACE_PRN_FN_ENT;

   244     gint status(TMS_RESULT_INVALID_STATE);

   245     switch (strmType)

   246         {

   247         case TMS_STREAM_UPLINK:

   248             {

   249             if (strmId == iUplinkStreamId && iIPUplink)

   250                 {

   251                 iIPUplink->Start();

   252                 status = TMS_RESULT_SUCCESS;

   253                 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);

   254                 }

   255             break;

   256             }

   257         case TMS_STREAM_DOWNLINK:

   258             {

   259             if (strmId == iDnlinkStreamId && iIPDownlink)

   260                 {

   261                 iIPDownlink->Start();

   262                 status = TMS_RESULT_SUCCESS;

   263                 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);

   264                 }

   265             break;

   266             }

   267         default:

   268             {

   269             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   270             break;

   271             }

   272         }

   273     TRACE_PRN_FN_EXT;

   274     return status;

   275     }

   276 

   277 // -----------------------------------------------------------------------------

   278 // TMSCallIPAdpt::PauseStream

   279 //

   280 // -----------------------------------------------------------------------------

   281 //

   282 gint TMSCallIPAdpt::PauseStream(TMSCallType /*callType*/,

   283         TMSStreamType strmType, gint strmId)

   284     {

   285     TRACE_PRN_FN_ENT;

   286     gint status(TMS_RESULT_INVALID_STATE);

   287     switch (strmType)

   288         {

   289         case TMS_STREAM_UPLINK:

   290             {

   291             if (strmId == iUplinkStreamId && iIPUplink)

   292                 {

   293                 iIPUplink->Stop();

   294                 status = TMS_RESULT_SUCCESS;

   295                 NotifyClient(iUplinkStreamId, ECmdUplinkPaused, status);

   296                 }

   297             break;

   298             }

   299         case TMS_STREAM_DOWNLINK:

   300             {

   301             if (strmId == iDnlinkStreamId && iIPDownlink)

   302                 {

   303                 iIPDownlink->Stop();

   304                 status = TMS_RESULT_SUCCESS;

   305                 NotifyClient(iDnlinkStreamId, ECmdDownlinkPaused, status);

   306                 }

   307             break;

   308             }

   309         default:

   310             {

   311             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   312             break;

   313             }

   314         }

   315     TRACE_PRN_FN_EXT;

   316     return status;

   317     }

   318 

   319 // -----------------------------------------------------------------------------

   320 // TMSCallIPAdpt::StopStream

   321 //

   322 // -----------------------------------------------------------------------------

   323 //

   324 gint TMSCallIPAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType,

   325         gint strmId)

   326     {

   327     TRACE_PRN_FN_ENT;

   328     gint status(TMS_RESULT_INVALID_STATE);

   329 

   330     switch (strmType)

   331         {

   332         case TMS_STREAM_UPLINK:

   333             {

   334             if (strmId == iUplinkStreamId && iIPUplink)

   335                 {

   336                 iIPUplink->Stop();

   337                 status = TMS_RESULT_SUCCESS;

   338                 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);

   339                 }

   340             break;

   341             }

   342         case TMS_STREAM_DOWNLINK:

   343             {

   344             if (strmId == iDnlinkStreamId && iIPDownlink)

   345                 {

   346                 iIPDownlink->Stop();

   347                 status = TMS_RESULT_SUCCESS;

   348                 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);

   349                 }

   350             break;

   351             }

   352         default:

   353             {

   354             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   355             break;

   356             }

   357         }

   358     TRACE_PRN_FN_EXT;

   359     return status;

   360     }

   361 

   362 // -----------------------------------------------------------------------------

   363 // TMSCallIPAdpt::DeinitStream

   364 //

   365 // -----------------------------------------------------------------------------

   366 //

   367 gint TMSCallIPAdpt::DeinitStream(TMSCallType /*callType*/,

   368         TMSStreamType strmType, gint strmId)

   369     {

   370     TRACE_PRN_FN_ENT;

   371     gint status(TMS_RESULT_INVALID_STATE);

   372 

   373     switch (strmType)

   374         {

   375         case TMS_STREAM_UPLINK:

   376             {

   377             if (strmId == iUplinkStreamId && iIPUplink)

   378                 {

   379                 iIPUplink->Stop();

   380                 //iUplinkStreamId = -1;

   381                 iUplinkInitialized = FALSE;

   382                 status = TMS_RESULT_SUCCESS;

   383                 NotifyClient(iUplinkStreamId, ECmdDownlinkDeInitComplete,

   384                         status);

   385                 }

   386             break;

   387             }

   388         case TMS_STREAM_DOWNLINK:

   389             {

   390             if (strmId == iDnlinkStreamId && iIPDownlink)

   391                 {

   392                 iIPDownlink->Stop();

   393                 //iDnlinkStreamId = -1;

   394                 iDnlinkInitialized = FALSE;

   395                 status = TMS_RESULT_SUCCESS;

   396                 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete,

   397                         status);

   398                 }

   399             break;

   400             }

   401         default:

   402             {

   403             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   404             break;

   405             }

   406         }

   407 

   408     TRACE_PRN_FN_EXT;

   409     return status;

   410     }

   411 

   412 // -----------------------------------------------------------------------------

   413 // TMSCallIPAdpt::DeleteStream

   414 //

   415 // -----------------------------------------------------------------------------

   416 //

   417 gint TMSCallIPAdpt::DeleteStream(TMSCallType /*callType*/,

   418         TMSStreamType strmType, gint strmId)

   419     {

   420     TRACE_PRN_FN_ENT;

   421     gint status(TMS_RESULT_SUCCESS);

   422     switch (strmType)

   423         {

   424         case TMS_STREAM_UPLINK:

   425             {

   426             // This is additional error checking

   427             if (strmId == iUplinkStreamId)

   428                 {

   429                 iUplinkStreamId = -1;

   430                 iUplinkInitialized = FALSE;

   431                 }

   432             break;

   433             }

   434         case TMS_STREAM_DOWNLINK:

   435             {

   436             // This is additional error checking

   437             if (strmId == iDnlinkStreamId)

   438                 {

   439                 iDnlinkStreamId = -1;

   440                 iDnlinkInitialized = FALSE;

   441                 }

   442             break;

   443             }

   444         default:

   445             {

   446             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   447             break;

   448             }

   449         }

   450     TRACE_PRN_FN_EXT;

   451     return status;

   452     }

   453 

   454 // -----------------------------------------------------------------------------

   455 // TMSCallIPAdpt::DataXferBufferEmptied

   456 //

   457 // -----------------------------------------------------------------------------

   458 //

   459 gint TMSCallIPAdpt::DataXferBufferEmptied(TMSCallType /*callType*/,

   460         TMSStreamType strmType, gint strmId)

   461     {

   462     TRACE_PRN_FN_ENT;

   463     gint status(TMS_RESULT_SUCCESS);

   464     switch (strmType)

   465         {

   466         case TMS_STREAM_UPLINK:

   467             {

   468             if (strmId == iUplinkStreamId)

   469                 {

   470                 TRAP(status, BufferEmptiedL());

   471                 }

   472             break;

   473             }

   474         case TMS_STREAM_DOWNLINK:

   475             status = TMS_RESULT_ILLEGAL_OPERATION;

   476             break;

   477         default:

   478             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   479             break;

   480         }

   481     TRACE_PRN_FN_EXT;

   482     return status;

   483     }

   484 

   485 // -----------------------------------------------------------------------------

   486 // TMSCallIPAdpt::DataXferBufferFilled

   487 //

   488 // -----------------------------------------------------------------------------

   489 //

   490 gint TMSCallIPAdpt::DataXferBufferFilled(TMSCallType /*callType*/,

   491         TMSStreamType strmType, gint strmId, guint datasize)

   492     {

   493     TRACE_PRN_FN_ENT;

   494     gint status(TMS_RESULT_SUCCESS);

   495     switch (strmType)

   496         {

   497         case TMS_STREAM_DOWNLINK:

   498             if (strmId == iDnlinkStreamId)

   499                 {

   500                 TRAP(status, BufferFilledL(datasize));

   501                 }

   502             break;

   503         case TMS_STREAM_UPLINK:

   504             status = TMS_RESULT_ILLEGAL_OPERATION;

   505             break;

   506         default:

   507             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   508             break;

   509         }

   510     TRACE_PRN_FN_EXT;

   511     return status;

   512     }

   513 

   514 // -----------------------------------------------------------------------------

   515 // TMSCallIPAdpt::GetDataXferBufferHndl

   516 //

   517 // -----------------------------------------------------------------------------

   518 //

   519 gint TMSCallIPAdpt::GetDataXferBufferHndl(const TMSCallType /*callType*/,

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

   521         RChunk& chunk)

   522     {

   523     TRACE_PRN_FN_ENT;

   524     gint status(TMS_RESULT_SUCCESS);

   525     switch (strmType)

   526         {

   527         case TMS_STREAM_DOWNLINK:

   528             {

   529             if (strmId == iDnlinkStreamId)

   530                 {

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

   532                 }

   533             break;

   534             }

   535         case TMS_STREAM_UPLINK:

   536             {

   537             if (strmId == iUplinkStreamId)

   538                 {

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

   540                 }

   541             break;

   542             }

   543         default:

   544             status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;

   545             break;

   546         }

   547     TRACE_PRN_FN_EXT;

   548     return status;

   549     }

   550 

   551 // -----------------------------------------------------------------------------

   552 // TMSCallIPAdpt::GetMaxVolume

   553 //

   554 // -----------------------------------------------------------------------------

   555 //

   556 gint TMSCallIPAdpt::GetMaxVolume(guint& volume)

   557     {

   558     TRACE_PRN_FN_ENT;

   559     gint status(TMS_RESULT_INVALID_STATE);

   560 

   561     if (iDnlinkInitialized && iIPDownlink)

   562         {

   563         status = iIPDownlink->GetMaxVolume(volume);

   564         iMaxVolume = volume;

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

   566         }

   567 

   568     TRACE_PRN_FN_EXT;

   569     return status;

   570     }

   571 

   572 // -----------------------------------------------------------------------------

   573 // TMSCallIPAdpt::SetVolume

   574 //

   575 // -----------------------------------------------------------------------------

   576 //

   577 gint TMSCallIPAdpt::SetVolume(const guint volume)

   578     {

   579     TRACE_PRN_FN_ENT;

   580     gint status(TMS_RESULT_INVALID_STATE);

   581     if (iDnlinkInitialized && iIPDownlink)

   582         {

   583         status = iIPDownlink->SetVolume(volume);

   584         NotifyClient(iDnlinkStreamId, ECmdSetVolume, status);

   585         }

   586     TRACE_PRN_FN_EXT;

   587     return status;

   588     }

   589 

   590 // -----------------------------------------------------------------------------

   591 // TMSCallIPAdpt::GetVolume

   592 //

   593 // -----------------------------------------------------------------------------

   594 //

   595 gint TMSCallIPAdpt::GetVolume(guint& volume)

   596     {

   597     TRACE_PRN_FN_ENT;

   598     gint status(TMS_RESULT_INVALID_STATE);

   599     if (iDnlinkInitialized && iIPDownlink)

   600         {

   601         status = iIPDownlink->GetVolume(volume);

   602         }

   603     TRACE_PRN_FN_EXT;

   604     return status;

   605     }

   606 

   607 // -----------------------------------------------------------------------------

   608 // TMSCallIPAdpt::GetMaxGain

   609 //

   610 // -----------------------------------------------------------------------------

   611 //

   612 gint TMSCallIPAdpt::GetMaxGain(guint& gain)

   613     {

   614     TRACE_PRN_FN_ENT;

   615     gint status(TMS_RESULT_INVALID_STATE);

   616     if (iUplinkInitialized && iIPUplink)

   617         {

   618         status = iIPUplink->GetMaxGain(gain);

   619         iMaxGain = gain;

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

   621         }

   622     TRACE_PRN_FN_EXT;

   623     return status;

   624     }

   625 

   626 // -----------------------------------------------------------------------------

   627 // TMSCallIPAdpt::SetGain

   628 //

   629 // -----------------------------------------------------------------------------

   630 //

   631 gint TMSCallIPAdpt::SetGain(const guint gain)

   632     {

   633     TRACE_PRN_FN_ENT;

   634     gint status(TMS_RESULT_INVALID_STATE);

   635     if (iUplinkInitialized && iIPUplink)

   636         {

   637         status = iIPUplink->SetGain(gain);

   638         NotifyClient(iUplinkStreamId, ECmdSetGain, status);

   639         }

   640     TRACE_PRN_FN_EXT;

   641     return status;

   642     }

   643 

   644 // -----------------------------------------------------------------------------

   645 // TMSCallIPAdpt::GetGain

   646 //

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

   648 //

   649 gint TMSCallIPAdpt::GetGain(guint& gain)

   650     {

   651     TRACE_PRN_FN_ENT;

   652     gint status(TMS_RESULT_INVALID_STATE);

   653     if (iUplinkInitialized && iIPUplink)

   654         {

   655         status = iIPUplink->GetGain(gain);

   656         }

   657     TRACE_PRN_FN_EXT;

   658     return status;

   659     }

   660 

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

   662 // TMSCallIPAdpt::GetGlobalMaxVolume

   663 //

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

   665 //

   666 gint TMSCallIPAdpt::GetGlobalMaxVolume(guint& volume)

   667     {

   668     TRACE_PRN_FN_ENT;

   669     gint status(TMS_RESULT_INVALID_STATE);

   670     if (iDnlinkInitialized && iIPDownlink)

   671         {

   672         status = iIPDownlink->GetMaxVolume(volume);

   673         iMaxVolume = volume;

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

   675         }

   676     TRACE_PRN_FN_EXT;

   677     return status;

   678     }

   679 

   680 // -----------------------------------------------------------------------------

   681 // TMSCallIPAdpt::SetGlobalVolume

   682 //

   683 // -----------------------------------------------------------------------------

   684 //

   685 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume)

   686     {

   687     TRACE_PRN_FN_ENT;

   688     gint status(TMS_RESULT_INVALID_STATE);

   689     if (iDnlinkInitialized && iIPDownlink)

   690         {

   691         status = iIPDownlink->SetVolume(volume);

   692         }

   693     TRACE_PRN_FN_EXT;

   694     return status;

   695     }

   696 

   697 // -----------------------------------------------------------------------------

   698 // TMSCallIPAdpt::GetGlobalVolume

   699 //

   700 // -----------------------------------------------------------------------------

   701 //

   702 gint TMSCallIPAdpt::GetGlobalVolume(guint& volume)

   703     {

   704     TRACE_PRN_FN_ENT;

   705     gint status(TMS_RESULT_INVALID_STATE);

   706     if (iDnlinkInitialized && iIPDownlink)

   707         {

   708         status = iIPDownlink->GetVolume(volume);

   709         }

   710     TRACE_PRN_FN_EXT;

   711     return status;

   712     }

   713 

   714 // -----------------------------------------------------------------------------

   715 // TMSCallIPAdpt::GetGlobalMaxGain

   716 //

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

   718 //

   719 gint TMSCallIPAdpt::GetGlobalMaxGain(guint& gain)

   720     {

   721     TRACE_PRN_FN_ENT;

   722     gint status(TMS_RESULT_INVALID_STATE);

   723     if (iUplinkInitialized && iIPUplink)

   724         {

   725         status = iIPUplink->GetMaxGain(gain);

   726         iMaxGain = gain;

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

   728         }

   729     TRACE_PRN_FN_EXT;

   730     return status;

   731     }

   732 

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

   734 // TMSCallIPAdpt::SetGlobalGain

   735 //

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

   737 //

   738 gint TMSCallIPAdpt::SetGlobalGain(const guint gain)

   739     {

   740     TRACE_PRN_FN_ENT;

   741     gint status(TMS_RESULT_INVALID_STATE);

   742     if (iUplinkInitialized && iIPUplink)

   743         {

   744         status = iIPUplink->SetGain(gain);

   745         }

   746     TRACE_PRN_FN_EXT;

   747     return status;

   748     }

   749 

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

   751 // TMSCallIPAdpt::GetGlobalGain

   752 //

   753 // -----------------------------------------------------------------------------

   754 //

   755 gint TMSCallIPAdpt::GetGlobalGain(guint& gain)

   756     {

   757     TRACE_PRN_FN_ENT;

   758     gint status(TMS_RESULT_INVALID_STATE);

   759     if (iUplinkInitialized && iIPUplink)

   760         {

   761         status = iIPUplink->GetGain(gain);

   762         }

   763     TRACE_PRN_FN_EXT;

   764     return status;

   765     }

   766 

   767 // -----------------------------------------------------------------------------

   768 // TMSCallIPAdpt::GetCodecMode

   769 //

   770 // -----------------------------------------------------------------------------

   771 //

   772 gint TMSCallIPAdpt::GetCodecMode(const TMSFormatType fmttype,

   773         const TMSStreamType strmtype, gint& mode)

   774     {

   775     TRACE_PRN_FN_ENT;

   776     gint status(TMS_RESULT_SUCCESS);

   777     switch (fmttype)

   778         {

   779         case TMS_FORMAT_ILBC:

   780             status = GetIlbcCodecMode(mode, strmtype);

   781             break;

   782         case TMS_FORMAT_G711:

   783             status = GetG711CodecMode(mode, strmtype);

   784             break;

   785         default:

   786             status = TMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED;

   787             break;

   788         }

   789     TRACE_PRN_FN_EXT;

   790     return status;

   791     }

   792 

   793 // -----------------------------------------------------------------------------

   794 // TMSCallIPAdpt::SetCodecMode

   795 //

   796 // -----------------------------------------------------------------------------

   797 //

   798 gint TMSCallIPAdpt::SetCodecMode(const TMSFormatType fmttype,

   799         const TMSStreamType strmtype, const gint mode)

   800     {

   801     TRACE_PRN_FN_ENT;

   802     gint status(TMS_RESULT_SUCCESS);

   803     switch (fmttype)

   804         {

   805         case TMS_FORMAT_ILBC:

   806             status = SetIlbcCodecMode(mode, strmtype);

   807             break;

   808         case TMS_FORMAT_G711:

   809             status = SetG711CodecMode(mode, strmtype);

   810             break;

   811         default:

   812             status = TMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED;

   813             break;

   814         }

   815     TRACE_PRN_FN_EXT;

   816     return status;

   817     }

   818 

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

   820 // TMSCallIPAdpt::GetSupportedBitRatesCount

   821 //

   822 // -----------------------------------------------------------------------------

   823 //

   824 gint TMSCallIPAdpt::GetSupportedBitRatesCount(guint& count)

   825     {

   826     TRACE_PRN_FN_ENT;

   827     gint status(TMS_RESULT_INVALID_STATE);

   828     if (iIPUplink)

   829         {

   830         status = iIPUplink->GetSupportedBitrates(iArrBitrates);

   831         count = iArrBitrates.Count();

   832         }

   833     TRACE_PRN_FN_EXT;

   834     return status;

   835     }

   836 

   837 // -----------------------------------------------------------------------------

   838 // TMSCallIPAdpt::GetSupportedBitRates

   839 //

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

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

   842 // back to the client.

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

   844 //

   845 gint TMSCallIPAdpt::GetSupportedBitRates(CBufFlat*& brbuffer)

   846     {

   847     TRAPD(status, GetSupportedBitRatesL(brbuffer));

   848     return status;

   849     }

   850 

   851 // -----------------------------------------------------------------------------

   852 // TMSCallIPAdpt::GetSupportedBitRatesL

   853 //

   854 // GetSupportedBitRates implementation which can leave.

   855 // -----------------------------------------------------------------------------

   856 //

   857 void TMSCallIPAdpt::GetSupportedBitRatesL(CBufFlat*& brbuffer)

   858     {

   859     TRACE_PRN_FN_ENT;

   860     RBufWriteStream stream;

   861     stream.Open(*brbuffer);

   862     CleanupClosePushL(stream);

   863     guint numOfItems = iArrBitrates.Count();

   864 

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

   866         {

   867         stream.WriteUint32L(iArrBitrates[i]);

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

   869         }

   870 

   871     CleanupStack::PopAndDestroy(&stream);

   872     TRACE_PRN_FN_EXT;

   873     }

   874 

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

   876 // TMSCallIPAdpt::GetBitRate

   877 //

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

   879 //

   880 gint TMSCallIPAdpt::GetBitRate(guint& bitrate)

   881     {

   882     TRACE_PRN_FN_ENT;

   883     gint status(TMS_RESULT_INVALID_STATE);

   884     if (iIPUplink)

   885         {

   886         status = iIPUplink->GetBitrate(bitrate);

   887         }

   888     TRACE_PRN_FN_EXT;

   889     return status;

   890     }

   891 

   892 // -----------------------------------------------------------------------------

   893 // TMSCallIPAdpt::SetBitRate

   894 //

   895 // -----------------------------------------------------------------------------

   896 //

   897 gint TMSCallIPAdpt::SetBitRate(const guint bitrate)

   898     {

   899     TRACE_PRN_FN_ENT;

   900     gint status(TMS_RESULT_INVALID_STATE);

   901     if (iIPUplink)

   902         {

   903         status = iIPUplink->SetBitrate(bitrate);

   904         }

   905     TRACE_PRN_FN_EXT;

   906     return status;

   907     }

   908 

   909 // -----------------------------------------------------------------------------

   910 // TMSCallIPAdpt::GetVAD

   911 //

   912 // -----------------------------------------------------------------------------

   913 //

   914 gint TMSCallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad)

   915     {

   916     TRACE_PRN_FN_ENT;

   917     gint status(TMS_RESULT_INVALID_STATE);

   918     if (iIPUplink)

   919         {

   920         status = iIPUplink->GetVad(fmttype, vad);

   921         }

   922     TRACE_PRN_FN_EXT;

   923     return status;

   924     }

   925 

   926 // -----------------------------------------------------------------------------

   927 // TMSCallIPAdpt::SetVAD

   928 //

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

   930 //

   931 gint TMSCallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad)

   932     {

   933     TRACE_PRN_FN_ENT;

   934     gint status(TMS_RESULT_INVALID_STATE);

   935     if (iIPUplink)

   936         {

   937         status = iIPUplink->SetVad(fmttype, vad);

   938         }

   939     TRACE_PRN_FN_EXT;

   940     return status;

   941     }

   942 

   943 // -----------------------------------------------------------------------------

   944 // TMSCallIPAdpt::GetCNG

   945 //

   946 // -----------------------------------------------------------------------------

   947 //

   948 gint TMSCallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng)

   949     {

   950     TRACE_PRN_FN_ENT;

   951     gint status(TMS_RESULT_INVALID_STATE);

   952     if (iIPDownlink)

   953         {

   954         status = iIPDownlink->GetCng(fmttype, cng);

   955         }

   956     TRACE_PRN_FN_EXT;

   957     return status;

   958     }

   959 

   960 // -----------------------------------------------------------------------------

   961 // TMSCallIPAdpt::SetCNG

   962 //

   963 // -----------------------------------------------------------------------------

   964 //

   965 gint TMSCallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng)

   966     {

   967     TRACE_PRN_FN_ENT;

   968     gint status(TMS_RESULT_INVALID_STATE);

   969     if (iIPDownlink)

   970         {

   971         status = iIPDownlink->SetCng(fmttype, cng);

   972         }

   973     TRACE_PRN_FN_EXT;

   974     return status;

   975     }

   976 

   977 // -----------------------------------------------------------------------------

   978 // TMSCallIPAdpt::GetPlc

   979 //

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

   981 //

   982 gint TMSCallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc)

   983     {

   984     TRACE_PRN_FN_ENT;

   985     gint status(TMS_RESULT_INVALID_STATE);

   986     if (iIPDownlink)

   987         {

   988         status = iIPDownlink->GetPlc(fmttype, plc);

   989         }

   990     TRACE_PRN_FN_EXT;

   991     return status;

   992     }

   993 

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

   995 // TMSCallIPAdpt::SetPlc

   996 //

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

   998 //

   999 gint TMSCallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc)

  1000     {

  1001     TRACE_PRN_FN_ENT;

  1002     gint status(TMS_RESULT_INVALID_STATE);

  1003     if (iIPDownlink)

  1004         {

  1005         status = iIPDownlink->SetPlc(fmttype, plc);

  1006         }

  1007     TRACE_PRN_FN_EXT;

  1008     return status;

  1009     }

  1010 

  1011 // -----------------------------------------------------------------------------

  1012 // TMSCallIPAdpt::OpenDownlinkL

  1013 // Method for player initialization.

  1014 // -----------------------------------------------------------------------------

  1015 //

  1016 gint TMSCallIPAdpt::OpenDownlinkL(const RMessage2& aMessage)

  1017     {

  1018     TRACE_PRN_FN_ENT;

  1019     gint status(TMS_RESULT_SUCCESS);

  1020 

  1021     // Clients must have MultimediaDD capability to use this priority/pref.

  1022     // TODO: Also, TMS will monitor for emergency call and if detected it

  1023     //       will deny access to audio resources.

  1024     iPriority.iPref = KAudioPrefVoipAudioDownlink;

  1025     iPriority.iPriority = KAudioPriorityVoipAudioDownlink;

  1026 

  1027     if (!iIPDownlink)

  1028         {

  1029         iIPDownlink = TMSIPDownlink::NewL(iDnFourCC, iPriority);

  1030         }

  1031 

  1032     if (iIPDownlink)

  1033         {

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

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

  1036             {

  1037             // Second argument in TMSCallProxy::InitStream

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

  1039             }

  1040 

  1041         if (status == TMS_RESULT_SUCCESS)

  1042             {

  1043             // For transfer data buffer processing

  1044             iIPDownlink->SetMsgQueue(iMsgQueueDn);

  1045             }

  1046         }

  1047 

  1048     TRACE_PRN_IF_ERR(status);

  1049     TRACE_PRN_FN_EXT;

  1050     return status;

  1051     }

  1052 

  1053 // -----------------------------------------------------------------------------

  1054 // TMSCallIPAdpt::OpenUplinkL

  1055 // Method for recorder initialization.

  1056 // -----------------------------------------------------------------------------

  1057 //

  1058 gint TMSCallIPAdpt::OpenUplinkL(const RMessage2& aMessage)

  1059     {

  1060     TRACE_PRN_FN_ENT;

  1061     gint status(TMS_RESULT_SUCCESS);

  1062 

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

  1064     iPriority.iPref = KAudioPrefVoipAudioUplink;

  1065     iPriority.iPriority = KAudioPriorityVoipAudioUplink;

  1066 

  1067     if (!iIPUplink)

  1068         {

  1069         iIPUplink = TMSIPUplink::NewL(iUpFourCC, iPriority);

  1070         }

  1071 

  1072     if (iIPUplink)

  1073         {

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

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

  1076             {

  1077             // Second argument in TMSCallProxy::InitStream

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

  1079             }

  1080 

  1081         if (status == TMS_RESULT_SUCCESS)

  1082             {

  1083             // For transfer data buffer processing

  1084             iIPUplink->SetMsgQueue(iMsgQueueUp);

  1085             }

  1086         }

  1087 

  1088     TRACE_PRN_IF_ERR(status);

  1089     TRACE_PRN_FN_EXT;

  1090     return status;

  1091     }

  1092 

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

  1094 // TMSCallIPAdpt::SetFormat

  1095 //

  1096 // -----------------------------------------------------------------------------

  1097 //

  1098 void TMSCallIPAdpt::SetFormat(const gint strmId, const TUint32 aFormat)

  1099     {

  1100     if (strmId == iUplinkStreamId)

  1101         {

  1102         iUpFourCC = aFormat;

  1103         }

  1104     else if (strmId == iDnlinkStreamId)

  1105         {

  1106         iDnFourCC = aFormat;

  1107         }

  1108     }

  1109 

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

  1111 // TMSCallIPAdpt::BufferFilled

  1112 //

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

  1114 //

  1115 void TMSCallIPAdpt::BufferFilledL(TUint dataSize)

  1116     {

  1117     if (iIPDownlink)

  1118         {

  1119         iIPDownlink->BufferFilled(dataSize);

  1120         }

  1121     }

  1122 

  1123 // -----------------------------------------------------------------------------

  1124 // TMSCallIPAdpt::BufferEmptied

  1125 //

  1126 // -----------------------------------------------------------------------------

  1127 //

  1128 void TMSCallIPAdpt::BufferEmptiedL()

  1129     {

  1130     if (iIPUplink)

  1131         {

  1132         iIPUplink->BufferEmptied();

  1133         }

  1134     }