Mercurial Mercurial > oss > FCL > sf > mw > mmappfw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mmappfw_plat/qt_telephony_multimedia_service_api/tsrc/qtmsvoiptest/qtmsvoiptest.cpp
changeset 51 e61a04404bdf
parent 35 2ee890d2f7e7
child 62 b276843a15ba
equal deleted inserted replaced
44:d141fc1ad77b 51:e61a04404bdf 
     1 /*
 
     1 /*
 
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
     3 * All rights reserved.
 
     3  * All rights reserved.
 
     4 * This component and the accompanying materials are made available
 
     4  * This component and the accompanying materials are made available
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     5  * under the terms of "Eclipse Public License v1.0"
 
     6 * which accompanies this distribution, and is available
 
     6  * which accompanies this distribution, and is available
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     8 *
 
     8  *
 
     9 * Initial Contributors:
 
     9  * Initial Contributors:
 
    10 * Nokia Corporation - initial contribution.
 
    10  * Nokia Corporation - initial contribution.
 
    11 *
 
    11  *
 
    12 * Contributors:
 
    12  * Contributors:
 
    13 *
 
    13  *
 
    14 * Description: QTMS Voip test
 
    14  * Description: QTMS Voip test
 
    15 *
 
    15  *
 
    16 */
 
    16  */
 
    17 #include <QObject>
 
    17 #include <QObject>
 
    18 #include <QtTest/QtTest>
 
    18 #include <QtTest/QtTest>
 
    19 #include "qtestmains60.h"
 
    19 #include "qtestmains60.h"
 
    20 
    20 
    21 #include <qtms.h>
 
    21 #include <qtms.h>
 
    43 #include <qtmsdtmf.h>
 
    43 #include <qtmsdtmf.h>
 
    44 #include <qtmsringtone.h>
 
    44 #include <qtmsringtone.h>
 
    45 #include <qtmsinbandtone.h>
 
    45 #include <qtmsinbandtone.h>
 
    46 #include <tmsbuffer.h>
 
    46 #include <tmsbuffer.h>
 
    47 
    47 
    48 
       
    49 // CONSTANTS
 
    48 // CONSTANTS
 
    50 #define __TEST_CODE_COVERAGE__
 
    49 #define __TEST_CODE_COVERAGE__
 
    51 
    50 
    52 using namespace QTMS;
 
    51 using namespace QTMS;
 
    53 
    52 
    54 class QTmsVoipTest : public QObject
 
    53 
    55     {
 
    54 class QTmsVoipTest: public QObject
 
       
    55 {
 
    56 Q_OBJECT
 
    56 Q_OBJECT
 
    57 private slots:
 
    57 private slots:
 
    58     void initTestCase();
 
    58     void initTestCase();
 
    59     void init();
 
    59     void init();
 
    60     void cleanup();
 
    60     void cleanup();
 
    71     void CreateBuffer();
 
    71     void CreateBuffer();
 
    72 
    72 
    73     void cleanupTestCase();
 
    73     void cleanupTestCase();
 
    74 public slots:
 
    74 public slots:
 
    75     //From TMSClientSourceObserver
 
    75     //From TMSClientSourceObserver
 
    76     void FillBuffer(TMS::TMSBuffer& buffer);
 
    76     void FillBuffer(QTMSBuffer& buffer);
 
    77     void BufferProcessed(TMS::TMSBuffer* buffer, gint reason);
 
    77     void BufferProcessed(QTMSBuffer* buffer, gint reason);
 
    78     //From TMSClientSinkObserver
 
    78     //From TMSClientSinkObserver
 
    79     void ProcessBuffer(const TMS::TMSBuffer* buffer);
 
    79     void ProcessBuffer(const QTMSBuffer* buffer);
 
    80     //From TMSStreamObserver
 
    80     //From TMSStreamObserver
 
    81     void TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event);
 
    81     void TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event);
 
    82     //From TMSClientSinkObserver
 
    82     //From TMSClientSinkObserver
 
    83     void EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event);
 
    83     void EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event);
 
    84     //From TMSGlobalRoutingObserver
 
    84     //From TMSGlobalRoutingObserver
 
    85     void GlobalRoutingEvent(const QTMSGlobalRouting& routing,
 
    85     void GlobalRoutingEvent(const QTMSGlobalRouting& routing, QTMSSignalEvent event,
 
    86             QTMSSignalEvent event, QTMSAudioOutput output);
 
    86         QTMSAudioOutput output);
 
    87     //From TMSRingToneObserver
 
    87     //From TMSRingToneObserver
 
    88     void RingtoneEvent(const QTMSRingTone& rt, QTMSSignalEvent event);
 
    88     void RingtoneEvent(const QTMSRingTone& rt, QTMSSignalEvent event);
 
    89     //From TMSDTMFObserver
 
    89     //From TMSDTMFObserver
 
    90     void DTMFEvent(const QTMSDTMF& dtmf, QTMSSignalEvent event);
 
    90     void DTMFEvent(const QTMSDTMF& dtmf, QTMSSignalEvent event);
 
    91 
    91 
   207 
   207 
   208     gboolean m_Vad;
 
   208     gboolean m_Vad;
 
   209     gboolean m_Cng;
 
   209     gboolean m_Cng;
 
   210     gboolean m_Plc;
 
   210     gboolean m_Plc;
 
   211 
   211 
   212     };
 
   212 };
 
   213 
   213 
   214 void QTmsVoipTest::initTestCase()
 
   214 void QTmsVoipTest::initTestCase()
 
   215     {
 
   215 {
 
   216     qDebug("Start QTms Voip tests");
 
   216     qDebug("Start QTms Voip tests");
 
   217     
   217 
   218     g_setenv("G_SLICE", "always-malloc", 1);
 
   218     g_setenv("G_SLICE", "always-malloc", 1);
 
   219     
   219 
   220     qRegisterMetaType<QTMSSignalEvent>("QTMSSignalEvent");
 
   220     qRegisterMetaType<QTMSSignalEvent> ("QTMSSignalEvent");
 
   221     qRegisterMetaType<QTMSAudioOutput>("QTMSAudioOutput");
 
   221     qRegisterMetaType<QTMSAudioOutput> ("QTMSAudioOutput");
 
   222     
   222 }
 
   223     }
 
       
   224 
   223 
   225 void QTmsVoipTest::cleanupTestCase()
 
   224 void QTmsVoipTest::cleanupTestCase()
 
   226     {
 
   225 {
 
   227     qDebug("End QTms tests");
 
   226     qDebug("End QTms tests");
 
   228     }
 
   227 }
 
   229 
   228 
   230 void QTmsVoipTest::init()
 
   229 void QTmsVoipTest::init()
 
   231     {
 
   230 {
 
   232     qDebug("****NEW TEST****");
 
   231     qDebug("****NEW TEST****");
 
   233     m_Factory = NULL;
 
   232     m_Factory = NULL;
 
   234     m_Call = NULL;
 
   233     m_Call = NULL;
 
   235     m_Dnlink = NULL;
 
   234     m_Dnlink = NULL;
 
   236     m_Uplink = NULL;  
   235     m_Uplink = NULL;
 
   237     m_MicSource = NULL;
 
   236     m_MicSource = NULL;
 
   238     m_ClientSource = NULL;
 
   237     m_ClientSource = NULL;
 
   239     m_SpeakerSink = NULL;
 
   238     m_SpeakerSink = NULL;
 
   240     m_ClientSink = NULL;
 
   239     m_ClientSink = NULL;
 
   241     m_Vol = NULL;
 
   240     m_Vol = NULL;
 
   242     m_Gain = NULL;
 
   241     m_Gain = NULL;
 
   243     m_GlobalVol = NULL;
 
   242     m_GlobalVol = NULL;
 
   244     m_GlobalGain = NULL;
 
   243     m_GlobalGain = NULL;
 
   245     m_Routing = NULL;  
   244     m_Routing = NULL;
 
   246     m_Dnlnkdtmf = NULL;
 
   245     m_Dnlnkdtmf = NULL;
 
   247     
   246 
   248     m_G711EncFormatIntfc = NULL;
 
   247     m_G711EncFormatIntfc = NULL;
 
   249     m_G711DecFormatIntfc = NULL;
 
   248     m_G711DecFormatIntfc = NULL;
 
   250     m_G729EncFormatIntfc = NULL;
 
   249     m_G729EncFormatIntfc = NULL;
 
   251     m_G729DecFormatIntfc = NULL;
 
   250     m_G729DecFormatIntfc = NULL;
 
   252     m_ILBCEncFormatIntfc = NULL;
 
   251     m_ILBCEncFormatIntfc = NULL;
 
   256     m_PCM16EncFormatIntfc = NULL;
 
   255     m_PCM16EncFormatIntfc = NULL;
 
   257     m_PCM16DecFormatIntfc = NULL;
 
   256     m_PCM16DecFormatIntfc = NULL;
 
   258 
   257 
   259     m_UplinkSpy = NULL;
 
   258     m_UplinkSpy = NULL;
 
   260     m_DnlinkSpy = NULL;
 
   259     m_DnlinkSpy = NULL;
 
   261     
   260 
   262     QTMSVer *ver(NULL);
 
   261     QTMSVer *ver(NULL);
 
   263     gint status;
 
   262     gint status;
 
   264     status = QTMSFactory::CreateFactory(m_Factory, *ver);
 
   263     status = QTMSFactory::CreateFactory(m_Factory, *ver);
 
   265     
   264 
   266     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   265     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   267       
   266 
   268     VoipCallSetup();
 
   267     VoipCallSetup();
 
   269     
   268 
   270     CreateUplink();
 
   269     CreateUplink();
 
   271     CreateDnlink();
 
   270     CreateDnlink();
 
   272      
   271 
   273     CreateMicSource();
 
   272     CreateMicSource();
 
   274     AddMicSourceToStream();
 
   273     AddMicSourceToStream();
 
   275      
   274 
   276     CreateClientSink();
 
   275     CreateClientSink();
 
   277     AddClientSinkToStream();
 
   276     AddClientSinkToStream();
 
   278      
   277 
   279     CreateClientSource();
 
   278     CreateClientSource();
 
   280     AddClientSourceToStream();
 
   279     AddClientSourceToStream();
 
   281      
   280 
   282     CreateSpeakerSink();
 
   281     CreateSpeakerSink();
 
   283     AddSpeakerSinkToStream();
 
   282     AddSpeakerSinkToStream();
 
   284     
   283 
   285     }
 
   284 }
 
   286 void QTmsVoipTest::cleanup()
 
   285 void QTmsVoipTest::cleanup()
 
   287     {
 
   286 {
 
   288     qDebug("****END TEST******");
 
   287     qDebug("****END TEST******");
 
   289 
   288 
   290     ResetUplnkFormat();
 
   289     ResetUplnkFormat();
 
   291     ResetDnlnkFormat();
 
   290     ResetDnlnkFormat();
 
   292 
   291 
   293     CloseUplink();
 
   292     CloseUplink();
 
   294     CloseDownlink();
 
   293     CloseDownlink();
 
   295 
   294 
   296     if (m_MicSource)
 
   295     if (m_MicSource) {
 
   297         m_Factory->DeleteSource(m_MicSource);
 
   296         m_Factory->DeleteSource(m_MicSource);
 
   298     if (m_ClientSource)
 
   297     }
 
       
   298     if (m_ClientSource) {
 
   299         m_Factory->DeleteSource(m_ClientSource);
 
   299         m_Factory->DeleteSource(m_ClientSource);
 
   300     if (m_ClientSink)
 
   300     }
 
       
   301     if (m_ClientSink) {
 
   301         m_Factory->DeleteSink(m_ClientSink);
 
   302         m_Factory->DeleteSink(m_ClientSink);
 
   302     if (m_SpeakerSink)
 
   303     }
 
       
   304     if (m_SpeakerSink) {
 
   303         m_Factory->DeleteSink(m_SpeakerSink);
 
   305         m_Factory->DeleteSink(m_SpeakerSink);
 
   304 
   306     }
 
   305     if (m_Dnlnkdtmf)
 
   307 
       
   308     if (m_Dnlnkdtmf) {
 
   306         m_Factory->DeleteDTMF(m_Dnlnkdtmf);
 
   309         m_Factory->DeleteDTMF(m_Dnlnkdtmf);
 
   307 
   310     }
 
   308     if (m_Vol)
 
   311 
       
   312     if (m_Vol) {
 
   309         m_Factory->DeleteEffect(m_Vol);
 
   313         m_Factory->DeleteEffect(m_Vol);
 
   310     if (m_Gain)
 
   314     }
 
       
   315     if (m_Gain) {
 
   311         m_Factory->DeleteEffect(m_Gain);
 
   316         m_Factory->DeleteEffect(m_Gain);
 
   312     if (m_GlobalVol)
 
   317     }
 
       
   318     if (m_GlobalVol) {
 
   313         m_Factory->DeleteEffect(m_GlobalVol);
 
   319         m_Factory->DeleteEffect(m_GlobalVol);
 
   314     if (m_GlobalGain)
 
   320     }
 
       
   321     if (m_GlobalGain) {
 
   315         m_Factory->DeleteEffect(m_GlobalGain);
 
   322         m_Factory->DeleteEffect(m_GlobalGain);
 
   316 
   323     }
 
   317     if (m_Routing)
 
   324 
       
   325     if (m_Routing) {
 
   318         m_Factory->DeleteGlobalRouting(m_Routing);
 
   326         m_Factory->DeleteGlobalRouting(m_Routing);
 
   319 
   327     }
 
   320     if (m_PCM16EncFormatIntfc)
 
   328 
       
   329     if (m_PCM16EncFormatIntfc) {
 
   321         m_Factory->DeleteFormat(m_PCM16EncFormatIntfc);
 
   330         m_Factory->DeleteFormat(m_PCM16EncFormatIntfc);
 
   322     if (m_ILBCEncFormatIntfc)
 
   331     }
 
       
   332     if (m_ILBCEncFormatIntfc) {
 
   323         m_Factory->DeleteFormat(m_ILBCEncFormatIntfc);
 
   333         m_Factory->DeleteFormat(m_ILBCEncFormatIntfc);
 
   324     if (m_AMRNBEncFormatIntfc)
 
   334     }
 
       
   335     if (m_AMRNBEncFormatIntfc) {
 
   325         m_Factory->DeleteFormat(m_AMRNBEncFormatIntfc);
 
   336         m_Factory->DeleteFormat(m_AMRNBEncFormatIntfc);
 
   326     if (m_G711EncFormatIntfc)
 
   337     }
 
       
   338     if (m_G711EncFormatIntfc) {
 
   327         m_Factory->DeleteFormat(m_G711EncFormatIntfc);
 
   339         m_Factory->DeleteFormat(m_G711EncFormatIntfc);
 
   328     if (m_G729EncFormatIntfc)
 
   340     }
 
       
   341     if (m_G729EncFormatIntfc) {
 
   329         m_Factory->DeleteFormat(m_G729EncFormatIntfc);
 
   342         m_Factory->DeleteFormat(m_G729EncFormatIntfc);
 
   330     if (m_PCM16DecFormatIntfc)
 
   343     }
 
       
   344     if (m_PCM16DecFormatIntfc) {
 
   331         m_Factory->DeleteFormat(m_PCM16DecFormatIntfc);
 
   345         m_Factory->DeleteFormat(m_PCM16DecFormatIntfc);
 
   332     if (m_ILBCDecFormatIntfc)
 
   346     }
 
       
   347     if (m_ILBCDecFormatIntfc) {
 
   333         m_Factory->DeleteFormat(m_ILBCDecFormatIntfc);
 
   348         m_Factory->DeleteFormat(m_ILBCDecFormatIntfc);
 
   334     if (m_AMRNBDecFormatIntfc)
 
   349     }
 
       
   350     if (m_AMRNBDecFormatIntfc) {
 
   335         m_Factory->DeleteFormat(m_AMRNBDecFormatIntfc);
 
   351         m_Factory->DeleteFormat(m_AMRNBDecFormatIntfc);
 
   336     if (m_G711DecFormatIntfc)
 
   352     }
 
       
   353     if (m_G711DecFormatIntfc) {
 
       
   354 
   337         m_Factory->DeleteFormat(m_G711DecFormatIntfc);
 
   355         m_Factory->DeleteFormat(m_G711DecFormatIntfc);
 
   338     if (m_G729DecFormatIntfc)
 
   356     }
 
       
   357     if (m_G729DecFormatIntfc) {
 
   339         m_Factory->DeleteFormat(m_G729DecFormatIntfc);
 
   358         m_Factory->DeleteFormat(m_G729DecFormatIntfc);
 
   340 
   359     }
 
   341     if (m_Uplink)
 
   360 
       
   361     if (m_Uplink) {
 
   342         m_Call->DeleteStream(m_Uplink);
 
   362         m_Call->DeleteStream(m_Uplink);
 
   343     if (m_Dnlink)
 
   363     }
 
       
   364     if (m_Dnlink) {
 
   344         m_Call->DeleteStream(m_Dnlink);
 
   365         m_Call->DeleteStream(m_Dnlink);
 
   345 
   366     }
 
   346     if (m_Call)
 
   367 
       
   368     if (m_Call) {
 
   347         m_Factory->DeleteCall(m_Call);
 
   369         m_Factory->DeleteCall(m_Call);
 
   348 
   370     }
 
   349     if (m_Factory)
 
   371 
       
   372     if (m_Factory) {
 
   350         delete m_Factory;
 
   373         delete m_Factory;
 
   351 
   374     }
 
   352     }
 
   375 
       
   376 }
 
   353 
   377 
   354 void QTmsVoipTest::VoipCallSetup()
 
   378 void QTmsVoipTest::VoipCallSetup()
 
   355     {
 
   379 {
 
   356     gint status(QTMS_RESULT_SUCCESS);
 
   380     gint status(QTMS_RESULT_SUCCESS);
 
   357     if (m_Factory && !m_Call)
 
   381     if (m_Factory && !m_Call) {
 
   358         {
 
       
   359         gboolean issupported(FALSE);
 
   382         gboolean issupported(FALSE);
 
   360         m_Factory->IsCallTypeSupported(QTMS_CALL_IP,issupported);
 
   383         m_Factory->IsCallTypeSupported(QTMS_CALL_IP, issupported);
 
   361         QVERIFY(issupported == TRUE);
 
   384         QVERIFY(issupported == TRUE);
 
   362         status = m_Factory->CreateCall(QTMS_CALL_IP, m_Call, 0);
 
   385         status = m_Factory->CreateCall(QTMS_CALL_IP, m_Call, 0);
 
   363         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   386         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   364         guint ctxid;
 
   387         guint ctxid;
 
   365         m_Call->GetCallContextId(ctxid);
 
   388         m_Call->GetCallContextId(ctxid);
 
   366         }
 
   389     }
 
   367     
   390 
   368     }
 
   391 }
 
   369 
   392 
   370 void QTmsVoipTest::SupportedFormats()
 
   393 void QTmsVoipTest::SupportedFormats()
 
   371     {
 
   394 {
 
   372     SupportedUplinkFormats();
 
   395     SupportedUplinkFormats();
 
   373     SupportedDnlinkFormats();
 
   396     SupportedDnlinkFormats();
 
   374     }
 
   397 }
 
   375 
   398 
   376 void QTmsVoipTest::SupportedUplinkFormats()
 
   399 void QTmsVoipTest::SupportedUplinkFormats()
 
   377     {
 
   400 {
 
   378     gint status(QTMS_RESULT_SUCCESS);
 
   401     gint status(QTMS_RESULT_SUCCESS);
 
   379     status = m_Factory->GetSupportedFormats(QTMS_STREAM_UPLINK,m_UplCodecs);
 
   402     status = m_Factory->GetSupportedFormats(QTMS_STREAM_UPLINK, m_UplCodecs);
 
   380     QVERIFY(status == QTMS_RESULT_SUCCESS);  
   403     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   381     
   404 
   382     qDebug("Supported UPL codecs");
 
   405     qDebug("Supported UPL codecs");
 
   383     std::vector<QTMSFormat*>::iterator codecs = m_UplCodecs.begin();
 
   406     std::vector<QTMSFormat*>::iterator codecs = m_UplCodecs.begin();
 
   384     QTMSFormatType fmttype;
 
   407     QTMSFormatType fmttype;
 
   385     for (; codecs < m_UplCodecs.end(); codecs++)
 
   408     for (; codecs < m_UplCodecs.end(); codecs++) {
 
   386         {
 
       
   387         (*codecs)->GetType(fmttype);
 
   409         (*codecs)->GetType(fmttype);
 
   388         DisplayFormat(fmttype);
 
   410         DisplayFormat(fmttype);
 
   389         }
 
   411     }
 
   390     gint size = m_UplCodecs.size();
 
   412     gint size = m_UplCodecs.size();
 
   391     for (gint i = 0; i < size; i++)
 
   413     for (gint i = 0; i < size; i++) {
 
   392         {
 
       
   393         codecs = m_UplCodecs.begin();
 
   414         codecs = m_UplCodecs.begin();
 
   394         m_Factory->DeleteFormat(*codecs);
 
   415         m_Factory->DeleteFormat(*codecs);
 
   395         m_UplCodecs.erase(codecs);
 
   416         m_UplCodecs.erase(codecs);
 
   396         }
 
   417     }
 
   397   
   418 
   398     }
 
   419 }
 
   399 
   420 
   400 void QTmsVoipTest::SupportedDnlinkFormats()
 
   421 void QTmsVoipTest::SupportedDnlinkFormats()
 
   401     {
 
   422 {
 
   402     gint status(QTMS_RESULT_SUCCESS);
 
   423     gint status(QTMS_RESULT_SUCCESS);
 
   403     status = m_Factory->GetSupportedFormats(QTMS_STREAM_DOWNLINK,m_DnlCodecs);
 
   424     status = m_Factory->GetSupportedFormats(QTMS_STREAM_DOWNLINK, m_DnlCodecs);
 
   404     QVERIFY(status == QTMS_RESULT_SUCCESS);  
   425     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   405     
   426 
   406     qDebug("Supported DNL codecs");
 
   427     qDebug("Supported DNL codecs");
 
   407     std::vector<QTMSFormat*>::iterator codecs = m_DnlCodecs.begin();
 
   428     std::vector<QTMSFormat*>::iterator codecs = m_DnlCodecs.begin();
 
   408     QTMSFormatType fmttype;
 
   429     QTMSFormatType fmttype;
 
   409     for (; codecs < m_DnlCodecs.end(); codecs++)
 
   430     for (; codecs < m_DnlCodecs.end(); codecs++) {
 
   410         {
 
       
   411         (*codecs)->GetType(fmttype);
 
   431         (*codecs)->GetType(fmttype);
 
   412         DisplayFormat(fmttype);
 
   432         DisplayFormat(fmttype);
 
   413         }
 
   433     }
 
   414     gint size = m_DnlCodecs.size();
 
   434     gint size = m_DnlCodecs.size();
 
   415     for (gint i = 0; i < size; i++)
 
   435     for (gint i = 0; i < size; i++) {
 
   416         {
 
       
   417         codecs = m_DnlCodecs.begin();
 
   436         codecs = m_DnlCodecs.begin();
 
   418         m_Factory->DeleteFormat(*codecs);
 
   437         m_Factory->DeleteFormat(*codecs);
 
   419         m_DnlCodecs.erase(codecs);
 
   438         m_DnlCodecs.erase(codecs);
 
   420         }
 
   439     }
 
   421     }
 
   440 }
 
   422 
       
   423 
   441 
   424 void QTmsVoipTest::DisplayFormat(QTMSFormatType format)
 
   442 void QTmsVoipTest::DisplayFormat(QTMSFormatType format)
 
   425     {
 
   443 {
 
   426     switch (format)
 
   444     switch (format) {
 
   427         {
 
   445     case QTMS_FORMAT_AMR:
 
   428         case QTMS_FORMAT_AMR:
 
   446         qDebug("AMR-NB");
 
   429             qDebug("AMR-NB");
 
   447         break;
 
   430             break;
 
   448     case QTMS_FORMAT_G711:
 
   431         case QTMS_FORMAT_G711:
 
   449         qDebug("G.711");
 
   432             qDebug("G.711");
 
   450         break;
 
   433             break;
 
   451     case QTMS_FORMAT_G729:
 
   434         case QTMS_FORMAT_G729:
 
   452         qDebug("G.729");
 
   435             qDebug("G.729");
 
   453         break;
 
   436             break;
 
   454     case QTMS_FORMAT_ILBC:
 
   437         case QTMS_FORMAT_ILBC:
 
   455         qDebug("iLBC");
 
   438             qDebug("iLBC");
 
   456         break;
 
   439             break;
 
   457     case QTMS_FORMAT_PCM:
 
   440         case QTMS_FORMAT_PCM:
 
   458         qDebug("PCM-16");
 
   441             qDebug("PCM-16");
 
   459         break;
 
   442             break;
 
   460     default:
 
   443         default:
 
   461         break;
 
   444             break;
 
   462     }
 
   445         }
 
   463 }
 
   446     }
 
       
   447 
   464 
   448 void QTmsVoipTest::CreateUplink()
 
   465 void QTmsVoipTest::CreateUplink()
 
   449     {
 
   466 {
 
   450     gint status(QTMS_RESULT_SUCCESS);
 
   467     gint status(QTMS_RESULT_SUCCESS);
 
   451 
   468 
   452     if (m_Call)
 
   469     if (m_Call) {
 
   453         {
 
       
   454         status = m_Call->CreateStream(QTMS_STREAM_UPLINK, m_Uplink);
 
   470         status = m_Call->CreateStream(QTMS_STREAM_UPLINK, m_Uplink);
 
   455 
   471 
   456         m_UplinkSpy = new QSignalSpy(m_Uplink,
 
   472         m_UplinkSpy = new QSignalSpy(m_Uplink,
 
   457                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   473             SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   458 
   474 
   459         QVERIFY( m_UplinkSpy->isValid() );
 
   475         QVERIFY( m_UplinkSpy->isValid() );
 
   460 
   476 
   461        // QCOMPARE(m_UplinkSpy->count(), 0 );
 
   477         // QCOMPARE(m_UplinkSpy->count(), 0 );
 
   462 
   478 
   463         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   479         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   464         connect(m_Uplink,
 
   480         connect(m_Uplink, SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)), this,
 
   465                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)),
 
   481             SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   466                 this,
 
   482     }
 
   467                 SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));  
   483 }
 
   468         }
 
   484 
   469     }
 
   485 void QTmsVoipTest::CreateDnlink()
 
   470 
   486 {
 
   471  void QTmsVoipTest::CreateDnlink()
 
   487     gint status(QTMS_RESULT_SUCCESS);
 
   472     {
 
   488 
   473     gint status(QTMS_RESULT_SUCCESS);
 
   489     if (m_Call) {
 
   474 
       
   475     if (m_Call)
 
       
   476         {
 
       
   477         status = m_Call->CreateStream(QTMS_STREAM_DOWNLINK, m_Dnlink);
 
   490         status = m_Call->CreateStream(QTMS_STREAM_DOWNLINK, m_Dnlink);
 
   478 
   491 
   479         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   492         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   480         
   493 
   481         m_DnlinkSpy = new QSignalSpy(m_Dnlink,
 
   494         m_DnlinkSpy = new QSignalSpy(m_Dnlink,
 
   482                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   495             SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   483 
   496 
   484         QVERIFY( m_DnlinkSpy->isValid() );
 
   497         QVERIFY( m_DnlinkSpy->isValid() );
 
   485 
   498 
   486        // QCOMPARE(m_DnlinkSpy->count(), 0 );
 
   499         // QCOMPARE(m_DnlinkSpy->count(), 0 );
 
   487         
   500 
   488         connect(m_Dnlink,
 
   501         connect(m_Dnlink, SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)), this,
 
   489                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)),
 
   502             SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   490                 this,
 
   503     }
 
   491                 SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));             
   504 }
 
   492         }
 
   505 
   493     }
 
       
   494  
       
   495 void QTmsVoipTest::CreateClientSource()
 
   506 void QTmsVoipTest::CreateClientSource()
 
   496      {
 
   507 {
 
   497      gint status(QTMS_RESULT_SUCCESS);
 
   508     gint status(QTMS_RESULT_SUCCESS);
 
   498      if (m_Factory && !m_ClientSource)
 
   509     if (m_Factory && !m_ClientSource) {
 
   499          {
 
   510         status = m_Factory->CreateSource(QTMS_SOURCE_CLIENT, m_ClientSource);
 
   500          status = m_Factory->CreateSource(QTMS_SOURCE_CLIENT, m_ClientSource);
 
   511     }
 
   501          }
 
   512     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   502      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   513 }
 
   503      }
 
       
   504  
       
   505 
   514 
   506 void QTmsVoipTest::AddClientSourceToStream()
 
   515 void QTmsVoipTest::AddClientSourceToStream()
 
   507     {
 
   516 {
 
   508     gint status(QTMS_RESULT_SUCCESS);
 
   517     gint status(QTMS_RESULT_SUCCESS);
 
   509     if (m_Dnlink && m_ClientSource)
 
   518     if (m_Dnlink && m_ClientSource) {
 
   510         {
 
       
   511         connect(static_cast<QTMSClientSource*> (m_ClientSource),
 
   519         connect(static_cast<QTMSClientSource*> (m_ClientSource),
 
   512                 SIGNAL(FillBuffer(TMS::TMSBuffer&)), this,
 
   520             SIGNAL(FillBuffer(QTMSBuffer&)), this, SLOT(FillBuffer(QTMSBuffer&)));
 
   513                 SLOT(FillBuffer(TMS::TMSBuffer&)));
 
       
   514         status = m_Dnlink->AddSource(m_ClientSource);
 
   521         status = m_Dnlink->AddSource(m_ClientSource);
 
   515         
   522 
   516 #ifdef __TEST_CODE_COVERAGE__
 
   523 #ifdef __TEST_CODE_COVERAGE__
 
   517         QTMSSourceType st;
 
   524         QTMSSourceType st;
 
   518         static_cast<QTMSClientSource*>(m_ClientSource)->GetType(st);
 
   525         static_cast<QTMSClientSource*> (m_ClientSource)->GetType(st);
 
   519         gboolean enqueue(FALSE);
 
   526         gboolean enqueue(FALSE);
 
   520         static_cast<QTMSClientSource*>(m_ClientSource)->GetEnqueueMode(enqueue);
 
   527         static_cast<QTMSClientSource*> (m_ClientSource)->GetEnqueueMode(enqueue);
 
   521         static_cast<QTMSClientSource*>(m_ClientSource)->SetEnqueueMode(FALSE);
 
   528         static_cast<QTMSClientSource*> (m_ClientSource)->SetEnqueueMode(FALSE);
 
   522         static_cast<QTMSClientSource*>(m_ClientSource)->Flush();
 
   529         static_cast<QTMSClientSource*> (m_ClientSource)->Flush();
 
   523 #endif //__TEST_CODE_COVERAGE__
 
   530 #endif //__TEST_CODE_COVERAGE__
 
   524         }
 
   531     }
 
   525     
   532 
   526     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   533     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   527     }
 
   534 }
 
   528 
   535 
   529 
   536 void QTmsVoipTest::CreateClientSink()
 
   530  void QTmsVoipTest::CreateClientSink()
 
   537 {
 
   531      {
 
   538     gint status(QTMS_RESULT_SUCCESS);
 
   532      gint status(QTMS_RESULT_SUCCESS);
 
   539 
   533 
   540     if (m_Factory && !m_ClientSink) {
 
   534      if (m_Factory && !m_ClientSink)
 
   541         status = m_Factory->CreateSink(QTMS_SINK_CLIENT, m_ClientSink);
 
   535          {
 
   542     }
 
   536          status = m_Factory->CreateSink(QTMS_SINK_CLIENT, m_ClientSink);
 
   543     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   537          }
 
   544 }
 
   538      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   545 
   539      } 
   546 void QTmsVoipTest::AddClientSinkToStream()
 
   540      
   547 {
 
   541  void QTmsVoipTest::AddClientSinkToStream()
 
   548     gint status(QTMS_RESULT_SUCCESS);
 
   542      {
 
   549     if (m_Uplink && m_ClientSink) {
 
   543      gint status(QTMS_RESULT_SUCCESS);
 
   550         connect(static_cast<QTMSClientSink*> (m_ClientSink),
 
   544      if (m_Uplink && m_ClientSink)
 
   551             SIGNAL(ProcessBuffer(const QTMSBuffer*)), this,
 
   545          {
 
   552             SLOT(ProcessBuffer(const QTMSBuffer*)));
 
   546          connect(static_cast<QTMSClientSink*> (m_ClientSink),
 
   553         status = m_Uplink->AddSink(m_ClientSink);
 
   547                  SIGNAL(ProcessBuffer(const TMS::TMSBuffer*)), this,
 
   554     }
 
   548                  SLOT(ProcessBuffer(const TMS::TMSBuffer*)));
 
   555     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   549          status = m_Uplink->AddSink(m_ClientSink);
 
   556 }
 
   550          }
 
   557 
   551      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   558 void QTmsVoipTest::CreateMicSource()
 
   552      }    
   559 {
 
   553  
   560     gint status(QTMS_RESULT_SUCCESS);
 
   554  
   561 
   555 
   562     if (m_Factory && !m_MicSource) {
 
   556  void QTmsVoipTest::CreateMicSource()
 
   563         status = m_Factory->CreateSource(TMS_SOURCE_MIC, m_MicSource);
 
   557      {
 
   564     }
 
   558      gint status(QTMS_RESULT_SUCCESS);
 
   565     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   559 
   566 }
 
   560      if (m_Factory && !m_MicSource)
 
   567 
   561          {
 
   568 void QTmsVoipTest::AddMicSourceToStream()
 
   562          status = m_Factory->CreateSource(TMS_SOURCE_MIC, m_MicSource);
 
   569 {
 
   563          }
 
   570     gint status(QTMS_RESULT_SUCCESS);
 
   564      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   571     if (m_Uplink && m_MicSource) {
 
   565      }
 
   572         status = m_Uplink->AddSource(m_MicSource);
 
   566 
   573     }
 
   567  void QTmsVoipTest::AddMicSourceToStream()
 
   574     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   568      {
 
   575 }
 
   569      gint status(QTMS_RESULT_SUCCESS);
 
   576 
   570      if (m_Uplink && m_MicSource)
 
   577 void QTmsVoipTest::CreateSpeakerSink()
 
   571          {
 
   578 {
 
   572          status = m_Uplink->AddSource(m_MicSource);
 
   579     gint status(QTMS_RESULT_SUCCESS);
 
   573          }
 
   580 
   574      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   581     if (m_Factory && !m_SpeakerSink) {
 
   575      }
 
   582         status = m_Factory->CreateSink(QTMS_SINK_SPEAKER, m_SpeakerSink);
 
   576 
   583     }
 
   577  void QTmsVoipTest::CreateSpeakerSink()
 
   584     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   578      {
 
   585 }
 
   579      gint status(QTMS_RESULT_SUCCESS);
 
   586 
   580 
   587 void QTmsVoipTest::AddSpeakerSinkToStream()
 
   581      if (m_Factory && !m_SpeakerSink)
 
   588 {
 
   582          {
 
   589     gint status(QTMS_RESULT_SUCCESS);
 
   583          status = m_Factory->CreateSink(QTMS_SINK_SPEAKER, m_SpeakerSink);
 
   590     if (m_Dnlink && m_SpeakerSink) {
 
   584          }
 
   591         status = m_Dnlink->AddSink(m_SpeakerSink);
 
   585      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   592     }
 
   586      }
 
   593     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   587 
   594 }
 
   588  void QTmsVoipTest::AddSpeakerSinkToStream()
 
   595 
   589      {
 
   596 void QTmsVoipTest::InitUplink()
 
   590      gint status(QTMS_RESULT_SUCCESS);
 
   597 {
 
   591      if (m_Dnlink && m_SpeakerSink)
 
   598     QVERIFY(m_Uplink->Init() == QTMS_RESULT_SUCCESS);
 
   592          {
 
   599     QTest::qWait(1000);
 
   593          status = m_Dnlink->AddSink(m_SpeakerSink);
 
   600     //QCOMPARE(m_UplinkSpy->count(), 1 );
 
   594          }
 
   601 
   595      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   602     GetSupportedBitrates();
 
   596      }
 
   603     SelectMinBitrate();
 
   597  
   604     SelectMaxBitrate();
 
   598  void QTmsVoipTest::InitUplink()
 
   605     GetBitrate();
 
   599      {    
   606 
   600      QVERIFY(m_Uplink->Init() == QTMS_RESULT_SUCCESS);
 
   607     ToggleVad();
 
   601      QTest::qWait(1000);  
   608     GetVad();
 
   602      //QCOMPARE(m_UplinkSpy->count(), 1 );
 
   609 
   603      
   610     SetUpLinkG711ALAW();
 
   604      GetSupportedBitrates();
 
   611     SetUpLinkG711uLAW();
 
   605      SelectMinBitrate();
 
   612     GetUpLinkG711Mode();
 
   606      SelectMaxBitrate();
 
   613 
   607      GetBitrate();
 
   614     SetUpLinkILBC20MS();
 
   608      
   615     SetUpLinkILBC30MS();
 
   609      ToggleVad();
 
   616     GetUpLinkILBCMode();
 
   610      GetVad();
 
   617 
   611       
   618 }
 
   612      SetUpLinkG711ALAW();
 
   619 
   613      SetUpLinkG711uLAW();
 
   620 void QTmsVoipTest::InitDnlink()
 
   614      GetUpLinkG711Mode();
 
   621 {
 
   615      
   622     QVERIFY(m_Dnlink->Init() == QTMS_RESULT_SUCCESS);
 
   616      SetUpLinkILBC20MS();
 
   623     QTest::qWait(1000);
 
   617      SetUpLinkILBC30MS();    
   624     //QCOMPARE(m_DnlinkSpy->count(), 1 );
 
   618      GetUpLinkILBCMode();
 
   625     ToggleCng();
 
   619      
   626     GetCng();
 
   620      }
 
   627     TogglePlc();
 
   621 
   628     GetPlc();
 
   622  void QTmsVoipTest::InitDnlink()
 
   629 
   623      {
 
   630     SetDnLinkG711ALAW();
 
   624      QVERIFY(m_Dnlink->Init() == QTMS_RESULT_SUCCESS);
 
   631     SetDnLinkG711uLAW();
 
   625      QTest::qWait(1000);      
   632     GetDnLinkG711Mode();
 
   626      //QCOMPARE(m_DnlinkSpy->count(), 1 );
 
   633 
   627      ToggleCng();
 
   634     SetDnLinkILBC20MS();
 
   628      GetCng();
 
   635     SetDnLinkILBC30MS();
 
   629      TogglePlc();
 
   636     GetDnLinkILBCMode();
 
   630      GetPlc();
 
   637 
   631     
   638 }
 
   632      SetDnLinkG711ALAW();
 
   639 void QTmsVoipTest::DeinitUplink()
 
   633      SetDnLinkG711uLAW();
 
   640 {
 
   634      GetDnLinkG711Mode();
 
   641     m_Uplink->Deinit();
 
   635      
   642     QTest::qWait(1000);
 
   636      SetDnLinkILBC20MS();
 
   643 }
 
   637      SetDnLinkILBC30MS();  
   644 
   638      GetDnLinkILBCMode();
 
   645 void QTmsVoipTest::DeinitDnlink()
 
   639    
   646 {
 
   640      }
 
   647     m_Dnlink->Deinit();
 
   641  void QTmsVoipTest::DeinitUplink()
 
   648     QTest::qWait(1000);
 
   642      {    
   649 }
 
   643      m_Uplink->Deinit();
 
   650 
   644      QTest::qWait(1000);   
   651 void QTmsVoipTest::StartUplink()
 
   645      }
 
   652 {
 
   646 
   653     QVERIFY(m_Uplink->Start() == QTMS_RESULT_SUCCESS);
 
   647  void QTmsVoipTest::DeinitDnlink()
 
   654     QTest::qWait(1000);
 
   648      {
 
   655     //QCOMPARE(m_UplinkSpy->count(), 2 );
 
   649      m_Dnlink->Deinit();
 
   656 }
 
   650      QTest::qWait(1000);      
   657 
   651      }
 
   658 void QTmsVoipTest::StartDnlink()
 
   652 
   659 {
 
   653  void QTmsVoipTest::StartUplink()
 
       
   654      {
 
       
   655      QVERIFY(m_Uplink->Start() == QTMS_RESULT_SUCCESS);
 
       
   656      QTest::qWait(1000);  
       
   657      //QCOMPARE(m_UplinkSpy->count(), 2 );
 
       
   658      }
 
       
   659 
       
   660  void QTmsVoipTest::StartDnlink()
 
       
   661     {
 
       
   662     QVERIFY(m_Dnlink->Start() == QTMS_RESULT_SUCCESS);
 
   660     QVERIFY(m_Dnlink->Start() == QTMS_RESULT_SUCCESS);
 
   663     QTest::qWait(1000);      
   661     QTest::qWait(1000);
 
   664     //QCOMPARE(m_DnlinkSpy->count(), 2 );
 
   662     //QCOMPARE(m_DnlinkSpy->count(), 2 );
 
   665     }
 
   663 }
 
   666 void QTmsVoipTest::StopUplink()
 
   664 void QTmsVoipTest::StopUplink()
 
   667     {
 
   665 {
 
   668 #ifdef __TEST_CODE_COVERAGE__
 
   666 #ifdef __TEST_CODE_COVERAGE__
 
   669     QVERIFY(m_Uplink->Pause()== QTMS_RESULT_SUCCESS);
 
   667     QVERIFY(m_Uplink->Pause()== QTMS_RESULT_SUCCESS);
 
   670     QTest::qWait(1000);  
   668     QTest::qWait(1000);
 
   671 #endif //__TEST_CODE_COVERAGE__
 
   669 #endif //__TEST_CODE_COVERAGE__
 
   672     
       
   673     QVERIFY(m_Uplink->Stop() == QTMS_RESULT_SUCCESS);
 
   670     QVERIFY(m_Uplink->Stop() == QTMS_RESULT_SUCCESS);
 
   674     QTest::qWait(1000);
 
   671     QTest::qWait(1000);
 
   675     //QCOMPARE(m_UplinkSpy->count(), 3 );
 
   672     //QCOMPARE(m_UplinkSpy->count(), 3 );
 
   676     }
 
   673 }
 
   677 
   674 
   678 void QTmsVoipTest::StopDnlink()
 
   675 void QTmsVoipTest::StopDnlink()
 
   679     {
 
   676 {
 
   680 #ifdef __TEST_CODE_COVERAGE__
 
   677 #ifdef __TEST_CODE_COVERAGE__
 
   681     QVERIFY(m_Dnlink->Pause() == QTMS_RESULT_SUCCESS);
 
   678     QVERIFY(m_Dnlink->Pause() == QTMS_RESULT_SUCCESS);
 
   682     QTest::qWait(1000);  
   679     QTest::qWait(1000);
 
   683 #endif //__TEST_CODE_COVERAGE__
 
   680 #endif //__TEST_CODE_COVERAGE__
 
   684     
       
   685     QVERIFY(m_Dnlink->Stop() == QTMS_RESULT_SUCCESS);
 
   681     QVERIFY(m_Dnlink->Stop() == QTMS_RESULT_SUCCESS);
 
   686     QTest::qWait(1000);  
   682     QTest::qWait(1000);
 
   687     //QCOMPARE(m_DnlinkSpy->count(), 3 );
 
   683     //QCOMPARE(m_DnlinkSpy->count(), 3 );
 
   688     }
 
   684 }
 
   689 
   685 
   690 void QTmsVoipTest::CloseUplink()
 
   686 void QTmsVoipTest::CloseUplink()
 
   691     {
 
   687 {
 
   692     m_Uplink->Deinit();
 
   688     m_Uplink->Deinit();
 
   693     QTest::qWait(1000);
 
   689     QTest::qWait(1000);
 
   694     if (m_Uplink)
 
   690     if (m_Uplink) {
 
   695         {
 
   691         if (m_Gain) {
 
   696         if (m_Gain)
 
       
   697             {
 
       
   698             QVERIFY(m_Uplink->RemoveEffect(m_Gain)== QTMS_RESULT_SUCCESS);
 
   692             QVERIFY(m_Uplink->RemoveEffect(m_Gain)== QTMS_RESULT_SUCCESS);
 
   699             }
 
   693         }
 
   700         if (m_MicSource)
 
   694         if (m_MicSource) {
 
   701             {
 
       
   702             QVERIFY(m_Uplink->RemoveSource(m_MicSource)== QTMS_RESULT_SUCCESS);
 
   695             QVERIFY(m_Uplink->RemoveSource(m_MicSource)== QTMS_RESULT_SUCCESS);
 
   703             }
 
   696         }
 
   704         if (m_ClientSink)
 
   697         if (m_ClientSink) {
 
   705             {
 
       
   706             QVERIFY(m_Uplink->RemoveSink(m_ClientSink)== QTMS_RESULT_SUCCESS);
 
   698             QVERIFY(m_Uplink->RemoveSink(m_ClientSink)== QTMS_RESULT_SUCCESS);
 
   707             }
 
   699         }
 
   708         }
 
   700     }
 
   709     }
 
   701 }
 
   710 
   702 
   711 void QTmsVoipTest::CloseDownlink()
 
   703 void QTmsVoipTest::CloseDownlink()
 
   712     {
 
   704 {
 
   713     m_Dnlink->Deinit();
 
   705     m_Dnlink->Deinit();
 
   714     QTest::qWait(1000);
 
   706     QTest::qWait(1000);
 
   715     if (m_Dnlink)
 
   707     if (m_Dnlink) {
 
   716         {
 
   708         if (m_Vol) {
 
   717         if (m_Vol)
 
       
   718             {
 
       
   719             QVERIFY(m_Dnlink->RemoveEffect(m_Vol)== QTMS_RESULT_SUCCESS);
 
   709             QVERIFY(m_Dnlink->RemoveEffect(m_Vol)== QTMS_RESULT_SUCCESS);
 
   720             }
 
   710         }
 
   721         if (m_ClientSource)
 
   711         if (m_ClientSource) {
 
   722             {
 
       
   723             QVERIFY(m_Dnlink->RemoveSource(m_ClientSource)== QTMS_RESULT_SUCCESS);
 
   712             QVERIFY(m_Dnlink->RemoveSource(m_ClientSource)== QTMS_RESULT_SUCCESS);
 
   724             }
 
   713         }
 
   725         if (m_SpeakerSink)
 
   714         if (m_SpeakerSink) {
 
   726             {
 
       
   727             QVERIFY(m_Dnlink->RemoveSink(m_SpeakerSink) == QTMS_RESULT_SUCCESS);
 
   715             QVERIFY(m_Dnlink->RemoveSink(m_SpeakerSink) == QTMS_RESULT_SUCCESS);
 
   728             }
 
   716         }
 
   729         }
 
   717     }
 
   730 
   718 
   731     }
 
   719 }
 
   732 
   720 
   733 void QTmsVoipTest::ResetUplnkFormat()
 
   721 void QTmsVoipTest::ResetUplnkFormat()
 
   734     {
 
   722 {
 
   735     if (m_Uplink)
 
   723     if (m_Uplink) {
 
   736         {
 
   724         switch (m_UpLinkCodec) {
 
   737         switch (m_UpLinkCodec)
 
   725         case QTMS_FORMAT_PCM:
 
   738             {
 
   726             m_Uplink->ResetFormat(m_PCM16EncFormatIntfc);
 
   739             case QTMS_FORMAT_PCM:
 
   727             break;
 
   740                 m_Uplink->ResetFormat(m_PCM16EncFormatIntfc);
 
   728         case QTMS_FORMAT_AMR:
 
   741                 break;
 
   729             m_Uplink->ResetFormat(m_AMRNBEncFormatIntfc);
 
   742             case QTMS_FORMAT_AMR:
 
   730             break;
 
   743                 m_Uplink->ResetFormat(m_AMRNBEncFormatIntfc);
 
   731         case QTMS_FORMAT_G711:
 
   744                 break;
 
   732             m_Uplink->ResetFormat(m_G711EncFormatIntfc);
 
   745             case QTMS_FORMAT_G711:
 
   733             break;
 
   746                 m_Uplink->ResetFormat(m_G711EncFormatIntfc);
 
   734         case QTMS_FORMAT_G729:
 
   747                 break;
 
   735             m_Uplink->ResetFormat(m_G729EncFormatIntfc);
 
   748             case QTMS_FORMAT_G729:
 
   736             break;
 
   749                 m_Uplink->ResetFormat(m_G729EncFormatIntfc);
 
   737         case QTMS_FORMAT_ILBC:
 
   750                 break;
 
   738             m_Uplink->ResetFormat(m_ILBCEncFormatIntfc);
 
   751             case QTMS_FORMAT_ILBC:
 
   739             break;
 
   752                 m_Uplink->ResetFormat(m_ILBCEncFormatIntfc);
 
   740         default:
 
   753                 break;
 
   741             break;
 
   754             default:
 
   742         }
 
   755                 break;
 
   743     }
 
   756             }
 
   744 
   757         }
 
   745 }
 
   758 
       
   759     }
 
       
   760 
   746 
   761 void QTmsVoipTest::ResetDnlnkFormat()
 
   747 void QTmsVoipTest::ResetDnlnkFormat()
 
   762     {
 
   748 {
 
   763     if (m_Dnlink)
 
   749     if (m_Dnlink) {
 
   764         {
 
   750         switch (m_DnLinkCodec) {
 
   765         switch (m_DnLinkCodec)
 
   751         case QTMS_FORMAT_PCM:
 
   766             {
 
   752             m_Dnlink->ResetFormat(m_PCM16DecFormatIntfc);
 
   767             case QTMS_FORMAT_PCM:
 
   753             break;
 
   768                 m_Dnlink->ResetFormat(m_PCM16DecFormatIntfc);
 
   754         case QTMS_FORMAT_AMR:
 
   769                 break;
 
   755             m_Dnlink->ResetFormat(m_AMRNBDecFormatIntfc);
 
   770             case QTMS_FORMAT_AMR:
 
   756             break;
 
   771                 m_Dnlink->ResetFormat(m_AMRNBDecFormatIntfc);
 
   757         case QTMS_FORMAT_G711:
 
   772                 break;
 
   758             m_Dnlink->ResetFormat(m_G711DecFormatIntfc);
 
   773             case QTMS_FORMAT_G711:
 
   759             break;
 
   774                 m_Dnlink->ResetFormat(m_G711DecFormatIntfc);
 
   760         case QTMS_FORMAT_G729:
 
   775                 break;
 
   761             m_Dnlink->ResetFormat(m_G729DecFormatIntfc);
 
   776             case QTMS_FORMAT_G729:
 
   762             break;
 
   777                 m_Dnlink->ResetFormat(m_G729DecFormatIntfc);
 
   763         case QTMS_FORMAT_ILBC:
 
   778                 break;
 
   764             m_Dnlink->ResetFormat(m_ILBCDecFormatIntfc);
 
   779             case QTMS_FORMAT_ILBC:
 
   765             break;
 
   780                 m_Dnlink->ResetFormat(m_ILBCDecFormatIntfc);
 
   766         default:
 
   781                 break;
 
   767             break;
 
   782             default:
 
   768         }
 
   783                 break;
 
   769     }
 
   784             }
 
   770 }
 
   785         }
 
       
   786     }
 
       
   787 
   771 
   788 void QTmsVoipTest::CreateFormat_data()
 
   772 void QTmsVoipTest::CreateFormat_data()
 
   789     {
 
   773 {
 
   790     QTest::addColumn<QTMSFormatType>("format");
 
   774     QTest::addColumn<QTMSFormatType>("format");
 
   791 
   775 
   792 #ifndef __WINSCW__
 
   776 #ifndef __WINSCW__
 
   793     QTest::newRow("G711")<<QTMS_FORMAT_G711;
 
   777     QTest::newRow("G711")<<QTMS_FORMAT_G711;
 
   794     QTest::newRow("G729")<<QTMS_FORMAT_G729;
 
   778     QTest::newRow("G729")<<QTMS_FORMAT_G729;
 
   795     QTest::newRow("iLBC")<<QTMS_FORMAT_ILBC;
 
   779     QTest::newRow("iLBC")<<QTMS_FORMAT_ILBC;
 
   796     QTest::newRow("AMR")<<QTMS_FORMAT_AMR;
 
   780     QTest::newRow("AMR")<<QTMS_FORMAT_AMR;
 
   797 #endif    
   781 #endif    
   798     QTest::newRow("PCM") << QTMS_FORMAT_PCM;
 
   782     QTest::newRow("PCM") << QTMS_FORMAT_PCM;
 
   799     }
 
   783 }
 
   800 
   784 
   801 void QTmsVoipTest::CreateFormat()
 
   785 void QTmsVoipTest::CreateFormat()
 
   802     {
 
   786 {
 
   803     gint decstatus(QTMS_RESULT_SUCCESS);
 
   787     gint decstatus(QTMS_RESULT_SUCCESS);
 
   804     gint encstatus(QTMS_RESULT_SUCCESS);
 
   788     gint encstatus(QTMS_RESULT_SUCCESS);
 
   805     gint setencstatus(QTMS_RESULT_SUCCESS);
 
   789     gint setencstatus(QTMS_RESULT_SUCCESS);
 
   806     gint setdecstatus(QTMS_RESULT_SUCCESS);
 
   790     gint setdecstatus(QTMS_RESULT_SUCCESS);
 
   807     QFETCH(QTMSFormatType, format);
 
   791     QFETCH(QTMSFormatType, format);
 
   808 
   792 
   809     m_DnLinkCodec = format;
 
   793     m_DnLinkCodec = format;
 
   810     m_UpLinkCodec = format;
 
   794     m_UpLinkCodec = format;
 
   811 
   795 
   812     switch (format)
 
   796     switch (format) {
 
   813         {
 
   797     case QTMS_FORMAT_G711:
 
   814         case QTMS_FORMAT_G711:
 
   798     {
 
   815             {
 
   799         decstatus = m_Factory->CreateFormat(QTMS_FORMAT_G711, m_G711DecFormatIntfc);
 
   816             decstatus = m_Factory->CreateFormat(QTMS_FORMAT_G711,
 
   800         encstatus = m_Factory->CreateFormat(QTMS_FORMAT_G711, m_G711EncFormatIntfc);
 
   817                     m_G711DecFormatIntfc);
 
   801         setdecstatus = m_Dnlink->SetFormat(m_G711DecFormatIntfc);
 
   818             encstatus = m_Factory->CreateFormat(QTMS_FORMAT_G711,
 
   802         setencstatus = m_Uplink->SetFormat(m_G711EncFormatIntfc);
 
   819                     m_G711EncFormatIntfc);
 
   803         qDebug("G.711 Set");
 
   820             setdecstatus = m_Dnlink->SetFormat(m_G711DecFormatIntfc);
 
   804 
   821             setencstatus = m_Uplink->SetFormat(m_G711EncFormatIntfc);
 
   805     }
 
   822             qDebug("G.711 Set");
 
   806         break;
 
   823 
   807     case QTMS_FORMAT_G729:
 
   824             }
 
   808     {
 
   825             break;
 
   809         decstatus = m_Factory->CreateFormat(QTMS_FORMAT_G729, m_G729DecFormatIntfc);
 
   826         case QTMS_FORMAT_G729:
 
   810         encstatus = m_Factory->CreateFormat(QTMS_FORMAT_G729, m_G729EncFormatIntfc);
 
   827             {
 
   811         setdecstatus = m_Dnlink->SetFormat(m_G729DecFormatIntfc);
 
   828             decstatus = m_Factory->CreateFormat(QTMS_FORMAT_G729,
 
   812         setdecstatus = m_Uplink->SetFormat(m_G729EncFormatIntfc);
 
   829                     m_G729DecFormatIntfc);
 
   813         qDebug("G.729 Set");
 
   830             encstatus = m_Factory->CreateFormat(QTMS_FORMAT_G729,
 
   814     }
 
   831                     m_G729EncFormatIntfc);
 
   815         break;
 
   832             setdecstatus = m_Dnlink->SetFormat(m_G729DecFormatIntfc);
 
   816     case QTMS_FORMAT_ILBC:
 
   833             setdecstatus = m_Uplink->SetFormat(m_G729EncFormatIntfc);
 
   817     {
 
   834             qDebug("G.729 Set");
 
   818         decstatus = m_Factory->CreateFormat(QTMS_FORMAT_ILBC, m_ILBCDecFormatIntfc);
 
   835             }
 
   819         encstatus = m_Factory->CreateFormat(QTMS_FORMAT_ILBC, m_ILBCEncFormatIntfc);
 
   836             break;
 
   820         setdecstatus = m_Dnlink->SetFormat(m_ILBCDecFormatIntfc);
 
   837         case QTMS_FORMAT_ILBC:
 
   821         setencstatus = m_Uplink->SetFormat(m_ILBCEncFormatIntfc);
 
   838             {
 
   822         qDebug("iLBC Set");
 
   839             decstatus = m_Factory->CreateFormat(QTMS_FORMAT_ILBC,
 
   823     }
 
   840                     m_ILBCDecFormatIntfc);
 
   824         break;
 
   841             encstatus = m_Factory->CreateFormat(QTMS_FORMAT_ILBC,
 
   825     case QTMS_FORMAT_AMR:
 
   842                     m_ILBCEncFormatIntfc);
 
   826     {
 
   843             setdecstatus = m_Dnlink->SetFormat(m_ILBCDecFormatIntfc);
 
   827         decstatus = m_Factory->CreateFormat(QTMS_FORMAT_AMR, m_AMRNBDecFormatIntfc);
 
   844             setencstatus = m_Uplink->SetFormat(m_ILBCEncFormatIntfc);
 
   828         encstatus = m_Factory->CreateFormat(QTMS_FORMAT_AMR, m_AMRNBEncFormatIntfc);
 
   845             qDebug("iLBC Set");
 
   829         setdecstatus = m_Dnlink->SetFormat(m_AMRNBDecFormatIntfc);
 
   846             }
 
   830         setencstatus = m_Uplink->SetFormat(m_AMRNBEncFormatIntfc);
 
   847             break;
 
   831         qDebug("AMR-NB Set");
 
   848         case QTMS_FORMAT_AMR:
 
   832     }
 
   849             {
 
   833         break;
 
   850             decstatus = m_Factory->CreateFormat(QTMS_FORMAT_AMR,
 
   834     case QTMS_FORMAT_PCM:
 
   851                     m_AMRNBDecFormatIntfc);
 
   835     {
 
   852             encstatus = m_Factory->CreateFormat(QTMS_FORMAT_AMR,
 
   836         decstatus = m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16DecFormatIntfc);
 
   853                     m_AMRNBEncFormatIntfc);
 
   837         encstatus = m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16EncFormatIntfc);
 
   854             setdecstatus = m_Dnlink->SetFormat(m_AMRNBDecFormatIntfc);
 
   838         setdecstatus = m_Dnlink->SetFormat(m_PCM16DecFormatIntfc);
 
   855             setencstatus = m_Uplink->SetFormat(m_AMRNBEncFormatIntfc);
 
   839         setencstatus = m_Uplink->SetFormat(m_PCM16EncFormatIntfc);
 
   856             qDebug("AMR-NB Set");
 
   840         qDebug("PCM-16 Set");
 
   857             }
 
   841     }
 
   858             break;
 
   842         break;
 
   859         case QTMS_FORMAT_PCM:
 
   843     default:
 
   860             {
 
   844         break;
 
   861             decstatus = m_Factory->CreateFormat(QTMS_FORMAT_PCM,
 
   845     }
 
   862                     m_PCM16DecFormatIntfc);
 
       
   863             encstatus = m_Factory->CreateFormat(QTMS_FORMAT_PCM,
 
       
   864                     m_PCM16EncFormatIntfc);
 
       
   865             setdecstatus = m_Dnlink->SetFormat(m_PCM16DecFormatIntfc);
 
       
   866             setencstatus = m_Uplink->SetFormat(m_PCM16EncFormatIntfc);
 
       
   867             qDebug("PCM-16 Set");
 
       
   868             }
 
       
   869             break;
 
       
   870         default:
 
       
   871             break;
 
       
   872         }
 
       
   873 
   846 
   874     QVERIFY(decstatus == QTMS_RESULT_SUCCESS);
 
   847     QVERIFY(decstatus == QTMS_RESULT_SUCCESS);
 
   875     QVERIFY(encstatus == QTMS_RESULT_SUCCESS);
 
   848     QVERIFY(encstatus == QTMS_RESULT_SUCCESS);
 
   876     QVERIFY(setdecstatus == QTMS_RESULT_SUCCESS);
 
   849     QVERIFY(setdecstatus == QTMS_RESULT_SUCCESS);
 
   877     QVERIFY(setencstatus == QTMS_RESULT_SUCCESS);
 
   850     QVERIFY(setencstatus == QTMS_RESULT_SUCCESS);
 
   878 
   851 
   879     InitUplink();
 
   852     InitUplink();
 
   880     InitDnlink();
 
   853     InitDnlink();
 
   881     }
 
   854 }
 
   882 
       
   883 
   855 
   884 void QTmsVoipTest::ToggleVad()
 
   856 void QTmsVoipTest::ToggleVad()
 
   885     {
 
   857 {
 
   886     //m_Vad = (m_Vad) ? EFalse : ETrue;
 
   858     //m_Vad = (m_Vad) ? EFalse : ETrue;
 
   887 
   859 
   888     m_Vad = ETrue;
 
   860     m_Vad = ETrue;
 
   889     switch (m_UpLinkCodec)
 
   861     switch (m_UpLinkCodec) {
 
   890         {
 
   862     case QTMS_FORMAT_G711:
 
   891         case QTMS_FORMAT_G711:
 
   863         static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->SetVADMode(m_Vad);
 
   892             static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->SetVADMode(
 
   864         qDebug("G711 VAD set %d", m_Vad);
 
   893                     m_Vad);
 
   865         break;
 
   894             qDebug("G711 VAD set %d", m_Vad);
 
   866     case QTMS_FORMAT_G729:
 
   895             break;
 
   867         static_cast<QTMSG729Format*> (m_G729EncFormatIntfc)->SetVADMode(m_Vad);
 
   896         case QTMS_FORMAT_G729:
 
   868         qDebug("G729 VAD set %d", m_Vad);
 
   897             static_cast<QTMSG729Format*> (m_G729EncFormatIntfc)->SetVADMode(
 
   869         break;
 
   898                     m_Vad);
 
   870     case QTMS_FORMAT_ILBC:
 
   899             qDebug("G729 VAD set %d",m_Vad);
 
   871         static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->SetVADMode(m_Vad);
 
   900             break;
 
   872         qDebug("iLBC VAD set %d", m_Vad);
 
   901         case QTMS_FORMAT_ILBC:
 
   873         break;
 
   902             static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->SetVADMode(
 
   874     case QTMS_FORMAT_AMR:
 
   903                     m_Vad);
 
   875         //static_cast<TMSAMRFormat*>(iAMRNBEncFormatIntfc)->SetVADMode(m_Vad);
 
   904             qDebug("iLBC VAD set %d",m_Vad);
 
   876         break;
 
   905             break;
 
   877     case QTMS_FORMAT_PCM:
 
   906         case QTMS_FORMAT_AMR:
 
   878         // Not supported; just for testing failing condition
 
   907             //static_cast<TMSAMRFormat*>(iAMRNBEncFormatIntfc)->SetVADMode(m_Vad);
 
   879         //static_cast<QTMSPCMFormat*>(iPCM16EncFormatIntfc)->SetVADMode(m_Vad);
 
   908             break;
 
   880         break;
 
   909         case QTMS_FORMAT_PCM:
 
   881     default:
 
   910             // Not supported; just for testing failing condition
 
   882         break;
 
   911             //static_cast<QTMSPCMFormat*>(iPCM16EncFormatIntfc)->SetVADMode(m_Vad);
 
   883     }
 
   912             break;
 
   884 }
 
   913         default:
 
       
   914             break;
 
       
   915         }
 
       
   916     }
 
       
   917 
       
   918 
   885 
   919 void QTmsVoipTest::GetVad()
 
   886 void QTmsVoipTest::GetVad()
 
   920     {   
   887 {
 
   921     gint status(QTMS_RESULT_SUCCESS);
 
   888     gint status(QTMS_RESULT_SUCCESS);
 
   922     gboolean vad = EFalse;
 
   889     gboolean vad = EFalse;
 
   923 
   890 
   924     switch (m_UpLinkCodec)
 
   891     switch (m_UpLinkCodec) {
 
   925         {
 
   892     case QTMS_FORMAT_G711:
 
   926         case QTMS_FORMAT_G711:
 
   893         status = static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->GetVADMode(vad);
 
   927             status = static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->GetVADMode(
 
   894         qDebug("get G711 VAD: %d", vad);
 
   928                     vad);
 
   895         break;
 
   929             qDebug("get G711 VAD: %d", vad);
 
   896     case QTMS_FORMAT_G729:
 
   930             break;
 
   897         status = static_cast<QTMSG729Format*> (m_G729EncFormatIntfc)->GetVADMode(vad);
 
   931         case QTMS_FORMAT_G729:
 
   898         qDebug("get G729 VAD: %d", vad);
 
   932             status = static_cast<QTMSG729Format*> (m_G729EncFormatIntfc)->GetVADMode(
 
   899         break;
 
   933                     vad);
 
   900     case QTMS_FORMAT_ILBC:
 
   934             qDebug("get G729 VAD: %d", vad);
 
   901         status = static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->GetVADMode(vad);
 
   935             break;
 
   902         qDebug("get iLBC VAD: %d", vad);
 
   936         case QTMS_FORMAT_ILBC:
 
   903         break;
 
   937             status = static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->GetVADMode(
 
   904     default:
 
   938                     vad);
 
   905         return;
 
   939             qDebug("get iLBC VAD: %d", vad);
 
   906     }
 
   940             break;
 
       
   941         default:
 
       
   942             return;
 
       
   943         }
 
       
   944     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   907     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   945    // QVERIFY(vad == m_Vad);
 
   908     // QVERIFY(vad == m_Vad);
 
   946 
   909 
   947 
   910 
   948     }
 
   911 }
 
   949 
   912 
   950 void QTmsVoipTest::ToggleCng()
 
   913 void QTmsVoipTest::ToggleCng()
 
   951     {
 
   914 {
 
   952 //    m_Cng = (m_Cng) ? EFalse : ETrue;
 
   915     //    m_Cng = (m_Cng) ? EFalse : ETrue;
 
   953 
   916 
   954     m_Cng = ETrue;
 
   917     m_Cng = ETrue;
 
   955     switch (m_DnLinkCodec)
 
   918     switch (m_DnLinkCodec) {
 
   956         {
 
   919     case QTMS_FORMAT_G711:
 
   957         case QTMS_FORMAT_G711:
 
   920         //case EG711_10MS:
 
   958             //case EG711_10MS:
 
   921         static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->SetCNG(m_Cng);
 
   959             static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->SetCNG(m_Cng);
 
   922         qDebug("G711 CNG set %d", m_Cng);
 
   960             qDebug("G711 CNG set %d", m_Cng);
 
   923         break;
 
   961             break;
 
   924     case QTMS_FORMAT_ILBC:
 
   962         case QTMS_FORMAT_ILBC:
 
   925         static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->SetCNG(m_Cng);
 
   963             static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->SetCNG(m_Cng);
 
   926         qDebug("iLBC CNG set %d", m_Cng);
 
   964             qDebug("iLBC CNG set %d", m_Cng);
 
   927         break;
 
   965             break;
 
   928     default:
 
   966         default:
 
   929         break;
 
   967             break;
 
   930     }
 
   968         }
 
   931 }
 
   969     }
 
       
   970 
       
   971 
   932 
   972 void QTmsVoipTest::GetCng()
 
   933 void QTmsVoipTest::GetCng()
 
   973     {
 
   934 {
 
   974     gint status;
 
   935     gint status;
 
   975     gboolean cng = EFalse;
 
   936     gboolean cng = EFalse;
 
   976     switch (m_DnLinkCodec)
 
   937     switch (m_DnLinkCodec) {
 
   977         {
 
   938     case QTMS_FORMAT_G711:
 
   978         case QTMS_FORMAT_G711:
 
   939         status = static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->GetCNG(cng);
 
   979             status = static_cast<QTMSG711Format*>(m_G711DecFormatIntfc)->GetCNG(cng);
 
   940         qDebug("G711 CNG: %d", cng);
 
   980             qDebug("G711 CNG: %d", cng);
 
   941         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   981             QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   942         break;
 
   982             break;
 
   943     case QTMS_FORMAT_ILBC:
 
   983         case QTMS_FORMAT_ILBC:
 
   944         status = static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->GetCNG(cng);
 
   984             status = static_cast<QTMSILBCFormat*>(m_ILBCDecFormatIntfc)->GetCNG(cng); 
   945         qDebug("iLBC CNG: %d", cng);
 
   985             qDebug("iLBC CNG: %d", cng);
 
   946         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   986             QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   947         break;
 
   987             break;
 
   948     default:
 
   988         default:
 
   949         break;
 
   989             break;
 
   950     }
 
   990         }
 
       
   991 
   951 
   992     // QVERIFY(cng == m_Cng);
 
   952     // QVERIFY(cng == m_Cng);
 
   993 
   953 
   994     }
 
   954 }
 
   995 
       
   996 
   955 
   997 void QTmsVoipTest::TogglePlc()
 
   956 void QTmsVoipTest::TogglePlc()
 
   998     {
 
   957 {
 
   999 //    m_Plc = (m_Plc) ? EFalse : ETrue;
 
   958     //    m_Plc = (m_Plc) ? EFalse : ETrue;
 
  1000     m_Plc = ETrue;
 
   959     m_Plc = ETrue;
 
  1001     if (m_DnLinkCodec == QTMS_FORMAT_G711)
 
   960     if (m_DnLinkCodec == QTMS_FORMAT_G711) {
 
  1002         {
 
       
  1003         static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->SetPlc(m_Plc);
 
   961         static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->SetPlc(m_Plc);
 
  1004         qDebug("G711 PLC set %d",m_Plc );
 
   962         qDebug("G711 PLC set %d", m_Plc);
 
  1005         }
 
   963     }
 
  1006     }
 
   964 }
 
  1007 
   965 
  1008 void QTmsVoipTest::GetPlc()
 
   966 void QTmsVoipTest::GetPlc()
 
  1009     {
 
   967 {
 
  1010     gboolean plc = EFalse;
 
   968     gboolean plc = EFalse;
 
  1011     if (m_G711DecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_G711)
 
   969     if (m_G711DecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_G711) {
 
  1012         {
 
   970         gint status = static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->GetPlc(plc);
 
  1013         gint status =
 
       
  1014                 static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->GetPlc(
 
       
  1015                         plc);
 
       
  1016         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   971         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1017         qDebug("G711 PLC: %d", plc);
 
   972         qDebug("G711 PLC: %d", plc);
 
  1018         // QVERIFY(plc == m_Plc);
 
   973         // QVERIFY(plc == m_Plc);
 
  1019         }
 
   974     }
 
  1020     }
 
   975 }
 
  1021 
       
  1022 
       
  1023 
   976 
  1024 void QTmsVoipTest::SelectMinBitrate()
 
   977 void QTmsVoipTest::SelectMinBitrate()
 
  1025     {
 
   978 {
 
  1026     if (m_BitratesVector.size() > 0)
 
   979     if (m_BitratesVector.size() > 0) {
 
  1027         {
 
       
  1028         std::vector<guint>::iterator bitrate = m_BitratesVector.begin();
 
   980         std::vector<guint>::iterator bitrate = m_BitratesVector.begin();
 
  1029         iBitrate = *bitrate;
 
   981         iBitrate = *bitrate;
 
  1030         SetBitrate(iBitrate);
 
   982         SetBitrate(iBitrate);
 
  1031         qDebug("BR set %d",iBitrate);
 
   983         qDebug("BR set %d", iBitrate);
 
  1032         }
 
   984     }
 
  1033     }
 
   985 }
 
  1034 
       
  1035 
   986 
  1036 void QTmsVoipTest::SelectMaxBitrate()
 
   987 void QTmsVoipTest::SelectMaxBitrate()
 
  1037     {
 
   988 {
 
  1038     if (m_BitratesVector.size() > 0)
 
   989     if (m_BitratesVector.size() > 0) {
 
  1039         {
 
       
  1040         iBitrate = m_BitratesVector.back();
 
   990         iBitrate = m_BitratesVector.back();
 
  1041         SetBitrate(iBitrate);
 
   991         SetBitrate(iBitrate);
 
  1042         qDebug("BR set %d",iBitrate);
 
   992         qDebug("BR set %d", iBitrate);
 
  1043         }
 
   993     }
 
  1044     }
 
   994 }
 
  1045 
       
  1046 
   995 
  1047 void QTmsVoipTest::SetBitrate(guint bitrate)
 
   996 void QTmsVoipTest::SetBitrate(guint bitrate)
 
  1048     {
 
   997 {
 
  1049     switch (m_UpLinkCodec)
 
   998     switch (m_UpLinkCodec) {
 
  1050         {
 
   999     case QTMS_FORMAT_G711:
 
  1051         case QTMS_FORMAT_G711:
 
  1000         static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->SetBitRate(bitrate);
 
  1052             static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->SetBitRate(
 
  1001         qDebug("Set BR %d", bitrate);
 
  1053                     bitrate);
 
  1002         break;
 
  1054             qDebug("Set BR %d",bitrate);
 
  1003     case QTMS_FORMAT_G729:
 
  1055             break;
 
  1004         static_cast<QTMSG729Format*> (m_G729EncFormatIntfc)->SetBitRate(bitrate);
 
  1056         case QTMS_FORMAT_G729:
 
  1005         qDebug("Set BR %d", bitrate);
 
  1057             static_cast<QTMSG729Format*> (m_G729EncFormatIntfc)->SetBitRate(
 
  1006         break;
 
  1058                     bitrate);
 
  1007     case QTMS_FORMAT_ILBC:
 
  1059             qDebug("Set BR %d",bitrate);
 
  1008         static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->SetBitRate(bitrate);
 
  1060             break;
 
  1009         qDebug("Set BR %d", bitrate);
 
  1061         case QTMS_FORMAT_ILBC:
 
  1010         break;
 
  1062             static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->SetBitRate(
 
  1011     case QTMS_FORMAT_AMR:
 
  1063                     bitrate);
 
  1012         static_cast<QTMSAMRFormat*> (m_AMRNBEncFormatIntfc)->SetBitRate(bitrate);
 
  1064             qDebug("Set BR %d",bitrate);
 
  1013         qDebug("Set BR %d", bitrate);
 
  1065             break;
 
  1014         break;
 
  1066         case QTMS_FORMAT_AMR:
 
  1015     case QTMS_FORMAT_PCM:
 
  1067             static_cast<QTMSAMRFormat*> (m_AMRNBEncFormatIntfc)->SetBitRate(
 
  1016     default:
 
  1068                     bitrate);
 
  1017         break;
 
  1069             qDebug("Set BR %d",bitrate);
 
  1018     }
 
  1070             break;
 
  1019 }
 
  1071         case QTMS_FORMAT_PCM:
 
       
  1072         default:
 
       
  1073             break;
 
       
  1074         }
 
       
  1075     }
 
       
  1076 
       
  1077 
  1020 
  1078 void QTmsVoipTest::GetSupportedBitrates()
 
  1021 void QTmsVoipTest::GetSupportedBitrates()
 
  1079     {
 
  1022 {
 
  1080     gint numOfItems(0);
 
  1023     gint numOfItems(0);
 
  1081     m_BitratesVector.clear();
 
  1024     m_BitratesVector.clear();
 
  1082     gint status = GetSupportedBitrates(m_BitratesVector);
 
  1025     gint status = GetSupportedBitrates(m_BitratesVector);
 
  1083 
  1026 
  1084     numOfItems = m_BitratesVector.size();
 
  1027     numOfItems = m_BitratesVector.size();
 
  1085     qDebug("BR Count %d", numOfItems);
 
  1028     qDebug("BR Count %d", numOfItems);
 
  1086     std::vector<guint>::iterator itBitrates = m_BitratesVector.begin();
 
  1029     std::vector<guint>::iterator itBitrates = m_BitratesVector.begin();
 
  1087     for (; itBitrates < m_BitratesVector.end(); itBitrates++)
 
  1030     for (; itBitrates < m_BitratesVector.end(); itBitrates++) {
 
  1088         {
 
       
  1089         qDebug("BR %d", *itBitrates);
 
  1031         qDebug("BR %d", *itBitrates);
 
  1090         }
 
  1032     }
 
  1091     }
 
  1033 }
 
  1092 
       
  1093 
  1034 
  1094 gint QTmsVoipTest::GetSupportedBitrates(BitRateVector& aBrArr)
 
  1035 gint QTmsVoipTest::GetSupportedBitrates(BitRateVector& aBrArr)
 
  1095     {
 
  1036 {
 
  1096     gint status(QTMS_RESULT_SUCCESS);
 
  1037     gint status(QTMS_RESULT_SUCCESS);
 
  1097 
  1038 
  1098     switch (m_UpLinkCodec)
 
  1039     switch (m_UpLinkCodec) {
 
  1099         {
 
  1040     case QTMS_FORMAT_G711:
 
  1100         case QTMS_FORMAT_G711:
 
  1041         status = m_G711EncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1101             status = m_G711EncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1042         break;
 
  1102             break;
 
  1043     case QTMS_FORMAT_G729:
 
  1103         case QTMS_FORMAT_G729:
 
  1044         status = m_G729EncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1104             status = m_G729EncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1045         break;
 
  1105             break;
 
  1046     case QTMS_FORMAT_ILBC:
 
  1106         case QTMS_FORMAT_ILBC:
 
  1047         status = m_ILBCEncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1107             status = m_ILBCEncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1048         break;
 
  1108             break;
 
  1049     case QTMS_FORMAT_AMR:
 
  1109         case QTMS_FORMAT_AMR:
 
  1050         status = m_AMRNBEncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1110             status = m_AMRNBEncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1051         break;
 
  1111             break;
 
  1052     case QTMS_FORMAT_PCM:
 
  1112         case QTMS_FORMAT_PCM:
 
  1053         // not supported, but test for correct error handling
 
  1113             // not supported, but test for correct error handling
 
  1054         //status = m_PCM16EncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1114             //status = m_PCM16EncFormatIntfc->GetSupportedBitRates(aBrArr);
 
  1055         break;
 
  1115             break;
 
  1056     default:
 
  1116         default:
 
  1057         status = KErrNotSupported;
 
  1117             status = KErrNotSupported;
 
  1058         break;
 
  1118             break;
 
  1059     }
 
  1119         }
 
       
  1120 
  1060 
  1121     return status;
 
  1061     return status;
 
  1122     }
 
  1062 }
 
  1123 
       
  1124 
  1063 
  1125 void QTmsVoipTest::GetBitrate()
 
  1064 void QTmsVoipTest::GetBitrate()
 
  1126     {
 
  1065 {
 
  1127     guint bitrate;
 
  1066     guint bitrate;
 
  1128     switch (m_UpLinkCodec)
 
  1067     switch (m_UpLinkCodec) {
 
  1129         {
 
  1068     case QTMS_FORMAT_G711:
 
  1130         case QTMS_FORMAT_G711:
 
  1069         static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->GetBitRate(bitrate);
 
  1131             static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->GetBitRate(
 
  1070         qDebug("G711 bitrate: %d", bitrate);
 
  1132                     bitrate);
 
  1071         break;
 
  1133             qDebug("G711 bitrate: %d", bitrate);
 
  1072     case QTMS_FORMAT_G729:
 
  1134             break;
 
  1073         static_cast<QTMSG729Format*> (m_G729EncFormatIntfc)->GetBitRate(bitrate);
 
  1135         case QTMS_FORMAT_G729:
 
  1074         qDebug("G729 bitrate: %d", bitrate);
 
  1136             static_cast<QTMSG729Format*> (m_G729EncFormatIntfc)->GetBitRate(
 
  1075         break;
 
  1137                     bitrate);
 
  1076     case QTMS_FORMAT_ILBC:
 
  1138             qDebug("G729 bitrate: %d", bitrate);
 
  1077         static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->GetBitRate(bitrate);
 
  1139             break;
 
  1078         qDebug("iLBC bitrate: %d", bitrate);
 
  1140         case QTMS_FORMAT_ILBC:
 
  1079         break;
 
  1141             static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->GetBitRate(
 
  1080     case QTMS_FORMAT_AMR:
 
  1142                     bitrate);
 
  1081         static_cast<QTMSAMRFormat*> (m_AMRNBEncFormatIntfc)->GetBitRate(bitrate);
 
  1143             qDebug("iLBC bitrate: %d", bitrate);
 
  1082         qDebug("AMR bitrate: %d", bitrate);
 
  1144             break;
 
  1083         break;
 
  1145         case QTMS_FORMAT_AMR:
 
  1084     case TMS_FORMAT_PCM:
 
  1146             static_cast<QTMSAMRFormat*> (m_AMRNBEncFormatIntfc)->GetBitRate(
 
  1085     default:
 
  1147                     bitrate);
 
  1086         break;
 
  1148             qDebug("AMR bitrate: %d", bitrate);
 
  1087     }
 
  1149             break;
 
  1088 }
 
  1150         case TMS_FORMAT_PCM:
 
       
  1151         default:
 
       
  1152             break;
 
       
  1153         }
 
       
  1154     }
 
       
  1155 
       
  1156 
  1089 
  1157 void QTmsVoipTest::SetDnLinkG711ALAW()
 
  1090 void QTmsVoipTest::SetDnLinkG711ALAW()
 
  1158     {
 
  1091 {
 
  1159     if (m_G711DecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_G711)
 
  1092     if (m_G711DecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_G711) {
 
  1160         {
 
       
  1161         gint status = static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->SetMode(
 
  1093         gint status = static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->SetMode(
 
  1162                 QTMS_G711_CODEC_MODE_ALAW);
 
  1094             QTMS_G711_CODEC_MODE_ALAW);
 
  1163         qDebug("SetDnLinkG711ALAW status %d",status);
 
  1095         qDebug("SetDnLinkG711ALAW status %d", status);
 
  1164         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1096         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1165         qDebug("DNL G.711 Mode Set: [aLaw]");
 
  1097         qDebug("DNL G.711 Mode Set: [aLaw]");
 
  1166         }
 
  1098     }
 
  1167     }
 
  1099 }
 
  1168 
       
  1169 
  1100 
  1170 void QTmsVoipTest::SetDnLinkG711uLAW()
 
  1101 void QTmsVoipTest::SetDnLinkG711uLAW()
 
  1171     {
 
  1102 {
 
  1172     if (m_G711DecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_G711)
 
  1103     if (m_G711DecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_G711) {
 
  1173         {
 
       
  1174         gint status = static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->SetMode(
 
  1104         gint status = static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->SetMode(
 
  1175                 QTMS_G711_CODEC_MODE_MULAW);
 
  1105             QTMS_G711_CODEC_MODE_MULAW);
 
  1176         qDebug("SetDnLinkG711uLAW status %d",status);
 
  1106         qDebug("SetDnLinkG711uLAW status %d", status);
 
  1177         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1107         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1178         qDebug("DNL G.711 Mode Set: [uLaw]");
 
  1108         qDebug("DNL G.711 Mode Set: [uLaw]");
 
  1179         }
 
  1109     }
 
  1180     }
 
  1110 }
 
  1181 
       
  1182 
  1111 
  1183 void QTmsVoipTest::GetDnLinkG711Mode()
 
  1112 void QTmsVoipTest::GetDnLinkG711Mode()
 
  1184     {
 
  1113 {
 
  1185     QTMSG711CodecMode mode;
 
  1114     QTMSG711CodecMode mode;
 
  1186     if (m_G711DecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_G711)
 
  1115     if (m_G711DecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_G711) {
 
  1187         {
 
  1116         gint status = static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->GetMode(mode);
 
  1188         gint status =
 
  1117         qDebug("GetDnLinkG711Mode status %d", status);
 
  1189                 static_cast<QTMSG711Format*> (m_G711DecFormatIntfc)->GetMode(
 
  1118         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1190                         mode);
 
  1119         if (mode == TMS_G711_CODEC_MODE_MULAW) {
 
  1191         qDebug("GetDnLinkG711Mode status %d",status);
 
       
  1192         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
  1193         if (mode == TMS_G711_CODEC_MODE_MULAW)
 
       
  1194             {
 
       
  1195             qDebug("DNL G711 Mode: [uLaw]");
 
  1120             qDebug("DNL G711 Mode: [uLaw]");
 
  1196             }
 
  1121         }
 
  1197         else
 
  1122         else {
 
  1198             {
 
       
  1199             qDebug("DNL G711 Mode: [aLaw]");
 
  1123             qDebug("DNL G711 Mode: [aLaw]");
 
  1200             }
 
  1124         }
 
  1201         }
 
  1125     }
 
  1202     }
 
  1126 }
 
  1203 
       
  1204 
  1127 
  1205 void QTmsVoipTest::SetDnLinkILBC20MS()
 
  1128 void QTmsVoipTest::SetDnLinkILBC20MS()
 
  1206     {
 
  1129 {
 
  1207     if (m_ILBCDecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_ILBC)
 
  1130     if (m_ILBCDecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_ILBC) {
 
  1208         {
 
  1131         gint status = static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->SetMode(
 
  1209         gint status =
 
  1132             TMS_ILBC_CODEC_MODE_20MS_FRAME);
 
  1210                 static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->SetMode(
 
  1133         qDebug("SetDnLinkILBC20MS status %d", status);
 
  1211                         TMS_ILBC_CODEC_MODE_20MS_FRAME);
 
       
  1212         qDebug("SetDnLinkILBC20MS status %d",status);
 
       
  1213         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1134         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1214         qDebug("DNL iLBC Mode Set: [20ms]");
 
  1135         qDebug("DNL iLBC Mode Set: [20ms]");
 
  1215         }
 
  1136     }
 
  1216     }
 
  1137 }
 
  1217 
       
  1218 
  1138 
  1219 void QTmsVoipTest::SetDnLinkILBC30MS()
 
  1139 void QTmsVoipTest::SetDnLinkILBC30MS()
 
  1220     {
 
  1140 {
 
  1221     if (m_ILBCDecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_ILBC)
 
  1141     if (m_ILBCDecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_ILBC) {
 
  1222         {
 
  1142         gint status = static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->SetMode(
 
  1223         gint status =
 
  1143             TMS_ILBC_CODEC_MODE_30MS_FRAME);
 
  1224                 static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->SetMode(
 
  1144         qDebug("SetDnLinkILBC30MS status %d", status);
 
  1225                         TMS_ILBC_CODEC_MODE_30MS_FRAME);
 
       
  1226         qDebug("SetDnLinkILBC30MS status %d",status);
 
       
  1227         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1145         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1228         qDebug("DNL iLBC Mode Set: [30ms]");
 
  1146         qDebug("DNL iLBC Mode Set: [30ms]");
 
  1229         }
 
  1147     }
 
  1230     }
 
  1148 }
 
  1231 
       
  1232 
  1149 
  1233 void QTmsVoipTest::GetDnLinkILBCMode()
 
  1150 void QTmsVoipTest::GetDnLinkILBCMode()
 
  1234     {
 
  1151 {
 
  1235     QTMSILBCCodecMode mode;
 
  1152     QTMSILBCCodecMode mode;
 
  1236     if (m_ILBCDecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_ILBC)
 
  1153     if (m_ILBCDecFormatIntfc && m_DnLinkCodec == QTMS_FORMAT_ILBC) {
 
  1237         {
 
  1154         gint status = static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->GetMode(mode);
 
  1238         gint status =
 
  1155         qDebug("GetDnLinkILBCMode status %d", status);
 
  1239                 static_cast<QTMSILBCFormat*> (m_ILBCDecFormatIntfc)->GetMode(
 
  1156 
  1240                         mode);
 
  1157         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1241         qDebug("GetDnLinkILBCMode status %d",status);
 
  1158         if (mode == QTMS_ILBC_CODEC_MODE_30MS_FRAME) {
 
  1242 
       
  1243         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
  1244         if (mode == QTMS_ILBC_CODEC_MODE_30MS_FRAME)
 
       
  1245             {
 
       
  1246             qDebug("DNL iLBC Mode: [30ms]");
 
  1159             qDebug("DNL iLBC Mode: [30ms]");
 
  1247             }
 
  1160         }
 
  1248         else if (mode == QTMS_ILBC_CODEC_MODE_20MS_FRAME)
 
  1161         else if (mode == QTMS_ILBC_CODEC_MODE_20MS_FRAME) {
 
  1249             {
 
       
  1250             qDebug("DNL iLBC Mode: [20ms]");
 
  1162             qDebug("DNL iLBC Mode: [20ms]");
 
  1251             }
 
  1163         }
 
  1252         }
 
  1164     }
 
  1253     }
 
  1165 }
 
  1254 
  1166 
  1255 void QTmsVoipTest::SetUpLinkG711ALAW()
 
  1167 void QTmsVoipTest::SetUpLinkG711ALAW()
 
  1256     {
 
  1168 {
 
  1257     if (m_G711EncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_G711)
 
  1169     if (m_G711EncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_G711) {
 
  1258         {
 
  1170         gint status = static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->SetMode(
 
  1259         gint status =
 
  1171             QTMS_G711_CODEC_MODE_ALAW);
 
  1260                 static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->SetMode(
 
  1172 
  1261                         QTMS_G711_CODEC_MODE_ALAW);
 
  1173         qDebug("SetUpLinkG711ALAW status %d", status);
 
  1262         
       
  1263         qDebug("SetUpLinkG711ALAW status %d",status);
 
       
  1264         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1174         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1265         qDebug("UPL G.711 Mode Set: [aLaw]");
 
  1175         qDebug("UPL G.711 Mode Set: [aLaw]");
 
  1266         }
 
  1176     }
 
  1267     }
 
  1177 }
 
  1268 
  1178 
  1269 void QTmsVoipTest::SetUpLinkG711uLAW()
 
  1179 void QTmsVoipTest::SetUpLinkG711uLAW()
 
  1270     {
 
  1180 {
 
  1271     if (m_G711EncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_G711)
 
  1181     if (m_G711EncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_G711) {
 
  1272         {
 
  1182         gint status = static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->SetMode(
 
  1273         gint status =
 
  1183             QTMS_G711_CODEC_MODE_MULAW);
 
  1274                 static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->SetMode(
 
  1184         qDebug("SetUpLinkG711uLAW status %d", status);
 
  1275                         QTMS_G711_CODEC_MODE_MULAW);
 
       
  1276         qDebug("SetUpLinkG711uLAW status %d",status);
 
       
  1277         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1185         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1278         qDebug("UPL G.711 Mode Set: [uLaw]");
 
  1186         qDebug("UPL G.711 Mode Set: [uLaw]");
 
  1279         }
 
  1187     }
 
  1280     }
 
  1188 }
 
  1281 
  1189 
  1282 void QTmsVoipTest::GetUpLinkG711Mode()
 
  1190 void QTmsVoipTest::GetUpLinkG711Mode()
 
  1283     {
 
  1191 {
 
  1284     QTMSG711CodecMode mode;
 
  1192     QTMSG711CodecMode mode;
 
  1285     if (m_G711EncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_G711)
 
  1193     if (m_G711EncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_G711) {
 
  1286         {
 
  1194         gint status = static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->GetMode(mode);
 
  1287         gint status =
 
  1195         qDebug("GetUpLinkG711Mode status %d", status);
 
  1288                 static_cast<QTMSG711Format*> (m_G711EncFormatIntfc)->GetMode(
 
  1196         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1289                         mode);
 
  1197         if (mode == QTMS_G711_CODEC_MODE_MULAW) {
 
  1290         qDebug("GetUpLinkG711Mode status %d",status);
 
       
  1291         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
  1292         if (mode == QTMS_G711_CODEC_MODE_MULAW)
 
       
  1293             {
 
       
  1294             qDebug("UPL G.711 Mode: [uLaw]");
 
  1198             qDebug("UPL G.711 Mode: [uLaw]");
 
  1295             }
 
  1199         }
 
  1296         else if (mode == QTMS_G711_CODEC_MODE_ALAW)
 
  1200         else if (mode == QTMS_G711_CODEC_MODE_ALAW) {
 
  1297             {
 
       
  1298             qDebug("UPL G.711 Mode: [aLaw]");
 
  1201             qDebug("UPL G.711 Mode: [aLaw]");
 
  1299             }
 
  1202         }
 
  1300         }
 
  1203     }
 
  1301 
  1204 
  1302     }
 
  1205 }
 
  1303 
       
  1304 
  1206 
  1305 void QTmsVoipTest::SetUpLinkILBC20MS()
 
  1207 void QTmsVoipTest::SetUpLinkILBC20MS()
 
  1306     {
 
  1208 {
 
  1307     if (m_ILBCEncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_ILBC)
 
  1209     if (m_ILBCEncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_ILBC) {
 
  1308         {
 
  1210         gint status = static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->SetMode(
 
  1309         gint status =
 
  1211             QTMS_ILBC_CODEC_MODE_20MS_FRAME);
 
  1310                 static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->SetMode(
 
  1212         qDebug("SetUpLinkILBC20MS status %d", status);
 
  1311                         QTMS_ILBC_CODEC_MODE_20MS_FRAME);
 
       
  1312         qDebug("SetUpLinkILBC20MS status %d",status);
 
       
  1313         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1213         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1314         qDebug("UPL iLBC Mode Set: [20ms]");
 
  1214         qDebug("UPL iLBC Mode Set: [20ms]");
 
  1315         }
 
  1215     }
 
  1316     }
 
  1216 }
 
  1317 
       
  1318 
  1217 
  1319 void QTmsVoipTest::SetUpLinkILBC30MS()
 
  1218 void QTmsVoipTest::SetUpLinkILBC30MS()
 
  1320     {
 
  1219 {
 
  1321     if (m_ILBCEncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_ILBC)
 
  1220     if (m_ILBCEncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_ILBC) {
 
  1322         {
 
  1221         gint status = static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->SetMode(
 
  1323         gint status =
 
  1222             QTMS_ILBC_CODEC_MODE_30MS_FRAME);
 
  1324                 static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->SetMode(
 
  1223         qDebug("SetUpLinkILBC30MS status %d", status);
 
  1325                         QTMS_ILBC_CODEC_MODE_30MS_FRAME);
 
       
  1326         qDebug("SetUpLinkILBC30MS status %d",status);
 
       
  1327         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1224         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1328         qDebug("UPL iLBC Mode Set: [30ms]");
 
  1225         qDebug("UPL iLBC Mode Set: [30ms]");
 
  1329         }
 
  1226     }
 
  1330     }
 
  1227 }
 
  1331 
  1228 
  1332 void QTmsVoipTest::GetUpLinkILBCMode()
 
  1229 void QTmsVoipTest::GetUpLinkILBCMode()
 
  1333     {
 
  1230 {
 
  1334     QTMSILBCCodecMode mode;
 
  1231     QTMSILBCCodecMode mode;
 
  1335     if (m_ILBCEncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_ILBC)
 
  1232     if (m_ILBCEncFormatIntfc && m_UpLinkCodec == QTMS_FORMAT_ILBC) {
 
  1336         {
 
  1233         gint status = static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->GetMode(mode);
 
  1337         gint status =
 
  1234         qDebug("GetUpLinkILBCMode status %d", status);
 
  1338                 static_cast<QTMSILBCFormat*> (m_ILBCEncFormatIntfc)->GetMode(
 
  1235         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1339                         mode);
 
  1236         if (mode == QTMS_ILBC_CODEC_MODE_30MS_FRAME) {
 
  1340         qDebug("GetUpLinkILBCMode status %d",status);
 
       
  1341         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
  1342         if (mode == QTMS_ILBC_CODEC_MODE_30MS_FRAME)
 
       
  1343             {
 
       
  1344             qDebug("UPL iLBC Mode: [30ms]");
 
  1237             qDebug("UPL iLBC Mode: [30ms]");
 
  1345             }
 
  1238         }
 
  1346         else if (mode == QTMS_ILBC_CODEC_MODE_20MS_FRAME)
 
  1239         else if (mode == QTMS_ILBC_CODEC_MODE_20MS_FRAME) {
 
  1347             {
 
       
  1348             qDebug("UPL iLBC Mode: [20ms]");
 
  1240             qDebug("UPL iLBC Mode: [20ms]");
 
  1349             }
 
  1241         }
 
  1350         }
 
  1242     }
 
  1351 
  1243 
  1352     }
 
  1244 }
 
  1353 
       
  1354 
  1245 
  1355 void QTmsVoipTest::CreateStreamVol()
 
  1246 void QTmsVoipTest::CreateStreamVol()
 
  1356     {
 
  1247 {
 
  1357     gint status(QTMS_RESULT_SUCCESS);
 
  1248     gint status(QTMS_RESULT_SUCCESS);
 
  1358    
  1249 
  1359     if (m_Factory && m_Dnlink && !m_Vol)
 
  1250     if (m_Factory && m_Dnlink && !m_Vol) {
 
  1360         {
 
       
  1361         m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16DecFormatIntfc);
 
  1251         m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16DecFormatIntfc);
 
  1362         m_Dnlink->SetFormat(m_PCM16DecFormatIntfc);
 
  1252         m_Dnlink->SetFormat(m_PCM16DecFormatIntfc);
 
  1363         
  1253 
  1364         status = m_Factory->CreateEffect(QTMS_EFFECT_VOLUME, m_Vol);
 
  1254         status = m_Factory->CreateEffect(QTMS_EFFECT_VOLUME, m_Vol);
 
  1365 
  1255 
  1366         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1256         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1367 
  1257 
  1368         connect(static_cast<QTMSVolumeEffect*> (m_Vol),
 
  1258         connect(static_cast<QTMSVolumeEffect*> (m_Vol),
 
  1369                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),
 
  1259             SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)), this,
 
  1370                 this, SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
  1260             SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
  1371         
  1261 
  1372         if(m_Dnlink)
 
  1262         if (m_Dnlink) {
 
  1373             {
 
  1263             status = m_Dnlink->AddEffect(m_Vol);
 
  1374             status = m_Dnlink->AddEffect(m_Vol);          
  1264         }
 
  1375             }
 
  1265         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1376         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1266 
  1377         
       
  1378         InitDnlink();
 
  1267         InitDnlink();
 
  1379         
  1268 
  1380         StreamVol();
 
  1269         StreamVol();
 
  1381 
  1270 
  1382         }
 
  1271     }
 
  1383     }
 
  1272 }
 
  1384 
  1273 
  1385 void QTmsVoipTest::StreamVol()
 
  1274 void QTmsVoipTest::StreamVol()
 
  1386     {
 
  1275 {
 
  1387     gint status(QTMS_RESULT_SUCCESS);
 
  1276     gint status(QTMS_RESULT_SUCCESS);
 
  1388     guint maxvol(0);
 
  1277     guint maxvol(0);
 
  1389     if (m_Vol)
 
  1278     if (m_Vol) {
 
  1390         {
 
       
  1391         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetMaxLevel(maxvol);
 
  1279         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetMaxLevel(maxvol);
 
  1392         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1280         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1393 
  1281 
  1394         status = static_cast<QTMSVolumeEffect*> (m_Vol)->SetLevel(maxvol);
 
  1282         status = static_cast<QTMSVolumeEffect*> (m_Vol)->SetLevel(maxvol);
 
  1395         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1283         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1398         guint vol(0);
 
  1286         guint vol(0);
 
  1399         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetLevel(vol);
 
  1287         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetLevel(vol);
 
  1400         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1288         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1401 
  1289 
  1402         QCOMPARE(vol,maxvol);
 
  1290         QCOMPARE(vol,maxvol);
 
  1403         }
 
  1291     }
 
  1404     }
 
  1292 }
 
  1405 
  1293 
  1406 void QTmsVoipTest::CreateStreamGain()
 
  1294 void QTmsVoipTest::CreateStreamGain()
 
  1407     {
 
  1295 {
 
  1408     gint status(QTMS_RESULT_SUCCESS);
 
  1296     gint status(QTMS_RESULT_SUCCESS);
 
  1409 
  1297 
  1410     if (m_Factory && m_Uplink && !m_Gain)
 
  1298     if (m_Factory && m_Uplink && !m_Gain) {
 
  1411         {
 
  1299 
  1412     
       
  1413         m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16EncFormatIntfc);
 
  1300         m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16EncFormatIntfc);
 
  1414         m_Uplink->SetFormat(m_PCM16EncFormatIntfc);
 
  1301         m_Uplink->SetFormat(m_PCM16EncFormatIntfc);
 
  1415         status = m_Factory->CreateEffect(QTMS_EFFECT_GAIN, m_Gain);
 
  1302         status = m_Factory->CreateEffect(QTMS_EFFECT_GAIN, m_Gain);
 
  1416         
  1303 
  1417         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1304         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1418 
  1305 
  1419         connect(static_cast<QTMSGainEffect*> (m_Gain),
 
  1306         connect(static_cast<QTMSGainEffect*> (m_Gain),
 
  1420                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),
 
  1307             SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)), this,
 
  1421                 this,
 
  1308             SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
  1422                 SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
  1309 
  1423         
  1310         status = m_Uplink->AddEffect(m_Gain);
 
  1424         status = m_Uplink->AddEffect(m_Gain);           
  1311         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1425         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1312 
  1426         
       
  1427         InitUplink();
 
  1313         InitUplink();
 
  1428         
  1314 
  1429         StreamGain();
 
  1315         StreamGain();
 
  1430         }
 
  1316     }
 
  1431     }
 
  1317 }
 
  1432 
  1318 
  1433 void QTmsVoipTest::StreamGain()
 
  1319 void QTmsVoipTest::StreamGain()
 
  1434     {
 
  1320 {
 
  1435     gint status(QTMS_RESULT_SUCCESS);
 
  1321     gint status(QTMS_RESULT_SUCCESS);
 
  1436     if (m_Gain)
 
  1322     if (m_Gain) {
 
  1437         {
 
       
  1438         guint maxgain(0);
 
  1323         guint maxgain(0);
 
  1439         static_cast<QTMSGainEffect*> (m_Gain)->GetMaxLevel(maxgain);
 
  1324         static_cast<QTMSGainEffect*> (m_Gain)->GetMaxLevel(maxgain);
 
  1440         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1325         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1441 
  1326 
  1442         static_cast<QTMSGainEffect*> (m_Gain)->SetLevel(maxgain);
 
  1327         static_cast<QTMSGainEffect*> (m_Gain)->SetLevel(maxgain);
 
  1446         guint gain(0);
 
  1331         guint gain(0);
 
  1447         static_cast<QTMSGainEffect*> (m_Gain)->GetLevel(gain);
 
  1332         static_cast<QTMSGainEffect*> (m_Gain)->GetLevel(gain);
 
  1448         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1333         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1449 
  1334 
  1450         QCOMPARE(gain,maxgain);
 
  1335         QCOMPARE(gain,maxgain);
 
  1451         }
 
  1336     }
 
  1452 
  1337 
  1453     }
 
  1338 }
 
  1454 
  1339 
  1455 void QTmsVoipTest::CreateGlobalVol()
 
  1340 void QTmsVoipTest::CreateGlobalVol()
 
  1456     {
 
  1341 {
 
  1457     gint status(QTMS_RESULT_SUCCESS);
 
  1342     gint status(QTMS_RESULT_SUCCESS);
 
  1458 
  1343 
  1459     if (m_Factory && !m_GlobalVol)
 
  1344     if (m_Factory && !m_GlobalVol) {
 
  1460         {
 
       
  1461         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_VOL, m_GlobalVol);
 
  1345         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_VOL, m_GlobalVol);
 
  1462 
  1346 
  1463         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1347         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1464 
  1348 
  1465         connect(static_cast<QTMSGlobalVolEffect*> (m_GlobalVol),
 
  1349         connect(static_cast<QTMSGlobalVolEffect*> (m_GlobalVol),
 
  1466                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),
 
  1350             SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)), this,
 
  1467                 this, SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
  1351             SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
  1468 
  1352 
  1469         guint maxvol(0);
 
  1353         guint maxvol(0);
 
  1470         status = static_cast<QTMSGlobalVolEffect*>(m_GlobalVol)->GetMaxLevel(
 
  1354         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetMaxLevel(maxvol);
 
  1471                 maxvol);
 
  1355         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1472         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1356         qDebug("global max vol %d", maxvol);
 
  1473         qDebug("global max vol %d",maxvol);
 
  1357 
  1474 
  1358         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->SetLevel(maxvol);
 
  1475         status = static_cast<QTMSGlobalVolEffect*>(m_GlobalVol)->SetLevel(
 
       
  1476                 maxvol);
 
       
  1477         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1359         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1478         QTest::qWait(1000);
 
  1360         QTest::qWait(1000);
 
  1479 
  1361 
  1480         guint vol(0);
 
  1362         guint vol(0);
 
  1481         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetLevel(vol);
 
  1363         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetLevel(vol);
 
  1482         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1364         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1483         qDebug("global vol %d",vol);
 
  1365         qDebug("global vol %d", vol);
 
  1484 
  1366 
  1485         QCOMPARE(vol,maxvol);
 
  1367         QCOMPARE(vol,maxvol);
 
  1486 
  1368 
  1487         }
 
  1369     }
 
  1488     }
 
  1370 }
 
  1489 
       
  1490 
  1371 
  1491 void QTmsVoipTest::CreateGlobalGain()
 
  1372 void QTmsVoipTest::CreateGlobalGain()
 
  1492     {
 
  1373 {
 
  1493     gint status(QTMS_RESULT_SUCCESS);
 
  1374     gint status(QTMS_RESULT_SUCCESS);
 
  1494 
  1375 
  1495     if (m_Factory && !m_GlobalGain)
 
  1376     if (m_Factory && !m_GlobalGain) {
 
  1496         {
 
       
  1497         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_GAIN, m_GlobalGain);
 
  1377         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_GAIN, m_GlobalGain);
 
  1498         
  1378 
  1499         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1379         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1500 
  1380 
  1501         connect(static_cast<QTMSGlobalGainEffect*> (m_GlobalGain),
 
  1381         connect(static_cast<QTMSGlobalGainEffect*> (m_GlobalGain),
 
  1502                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),
 
  1382             SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)), this,
 
  1503                 this,
 
  1383             SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
  1504                 SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
  1384 
  1505         
       
  1506         guint maxgain(0);
 
  1385         guint maxgain(0);
 
  1507         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->GetMaxLevel(maxgain);
 
  1386         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->GetMaxLevel(maxgain);
 
  1508         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1387         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1509         qDebug("global max gain %d",maxgain);
 
  1388         qDebug("global max gain %d", maxgain);
 
  1510         
  1389 
  1511         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->SetLevel(maxgain);
 
  1390         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->SetLevel(maxgain);
 
  1512         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1391         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1513         QTest::qWait(1000);
 
  1392         QTest::qWait(1000);
 
  1514         
  1393 
  1515         guint gain(0);
 
  1394         guint gain(0);
 
  1516         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->GetLevel(gain);
 
  1395         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->GetLevel(gain);
 
  1517         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1396         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1518         qDebug("global gain %d",gain);
 
  1397         qDebug("global gain %d", gain);
 
  1519         
  1398 
  1520         QCOMPARE(gain,maxgain);
 
  1399         QCOMPARE(gain,maxgain);
 
  1521   
  1400 
  1522         }
 
  1401     }
 
  1523     }
 
  1402 }
 
  1524 
  1403 
  1525 void QTmsVoipTest::CreateRouting_data()
 
  1404 void QTmsVoipTest::CreateRouting_data()
 
  1526     {
 
  1405 {
 
  1527  
  1406 
  1528     QTest::addColumn<QTMSAudioOutput>("routing");
 
  1407     QTest::addColumn<QTMSAudioOutput>("routing");
 
  1529     
  1408 
  1530     QTest::newRow("Public")<<QTMS_AUDIO_OUTPUT_PUBLIC;
 
  1409     QTest::newRow("Public") << QTMS_AUDIO_OUTPUT_PUBLIC;
 
  1531     QTest::newRow("Private")<<QTMS_AUDIO_OUTPUT_PRIVATE;
 
  1410     QTest::newRow("Private") << QTMS_AUDIO_OUTPUT_PRIVATE;
 
  1532  
  1411 
  1533 
  1412 }
 
  1534     }
 
       
  1535 
  1413 
  1536 void QTmsVoipTest::CreateRouting()
 
  1414 void QTmsVoipTest::CreateRouting()
 
  1537     {
 
  1415 {
 
  1538     gint status(QTMS_RESULT_SUCCESS);
 
  1416     gint status(QTMS_RESULT_SUCCESS);
 
  1539     
       
  1540     QFETCH(QTMSAudioOutput, routing);
 
  1417     QFETCH(QTMSAudioOutput, routing);
 
  1541        
  1418 
  1542     if (m_Factory && !m_Routing)
 
  1419     if (m_Factory && !m_Routing) {
 
  1543         {
 
       
  1544         m_UpLinkCodec = QTMS_FORMAT_PCM;
 
  1420         m_UpLinkCodec = QTMS_FORMAT_PCM;
 
  1545         m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16DecFormatIntfc);
 
  1421         m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16DecFormatIntfc);
 
  1546         m_Dnlink->SetFormat(m_PCM16DecFormatIntfc);
 
  1422         m_Dnlink->SetFormat(m_PCM16DecFormatIntfc);
 
  1547 
  1423 
  1548         InitDnlink();
 
  1424         InitDnlink();
 
  1549         StartDnlink();
 
  1425         StartDnlink();
 
  1550         
  1426 
  1551         status = m_Factory->CreateGlobalRouting(m_Routing);
 
  1427         status = m_Factory->CreateGlobalRouting(m_Routing);
 
  1552         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1428         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1553 
  1429 
  1554         m_RoutingSpy = new QSignalSpy(m_Routing,
 
  1430         m_RoutingSpy = new QSignalSpy(m_Routing,
 
  1555                       SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,
 
  1431             SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,
 
  1556                               QTMSSignalEvent,
 
  1432                     QTMSSignalEvent,
 
  1557                               QTMSAudioOutput)));
 
  1433                     QTMSAudioOutput)));
 
  1558 
  1434 
  1559         QVERIFY( m_RoutingSpy->isValid() );
 
  1435         QVERIFY( m_RoutingSpy->isValid() );
 
  1560 
  1436 
  1561         //QCOMPARE(m_RoutingSpy->count(), 0 );
 
  1437         //QCOMPARE(m_RoutingSpy->count(), 0 );
 
  1562         connect(m_Routing,
 
  1438         connect(m_Routing,
 
  1563                 SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,QTMSSignalEvent,QTMSAudioOutput)),
 
  1439             SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,QTMSSignalEvent,QTMSAudioOutput)),
 
  1564                 this,
 
  1440             this,
 
  1565                 SLOT(GlobalRoutingEvent(const QTMSGlobalRouting&,QTMSSignalEvent,QTMSAudioOutput)));
 
  1441             SLOT(GlobalRoutingEvent(const QTMSGlobalRouting&,QTMSSignalEvent,QTMSAudioOutput)));
 
  1566         }
 
  1442     }
 
  1567       
  1443 
  1568     if(m_Routing)
 
  1444     if (m_Routing) {
 
  1569         {
 
       
  1570         status = m_Routing->SetOutput(routing);
 
  1445         status = m_Routing->SetOutput(routing);
 
  1571         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1446         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1572 #ifndef __WINSCW__
 
  1447 #ifndef __WINSCW__
 
  1573         QTest::qWait(1000);            
  1448         QTest::qWait(1000);
 
  1574         //QCOMPARE(m_RoutingSpy->count(), 1 );
 
  1449         //QCOMPARE(m_RoutingSpy->count(), 1 );
 
  1575 #endif
 
  1450 #endif
 
  1576         QTMSAudioOutput current;     
  1451         QTMSAudioOutput current;
 
  1577         status = m_Routing->GetOutput(current);
 
  1452         status = m_Routing->GetOutput(current);
 
  1578         DisplayDevice(current);
 
  1453         DisplayDevice(current);
 
  1579 
  1454 
  1580         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1455         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1581 #ifndef __WINSCW__      
  1456 #ifndef __WINSCW__      
  1582         QCOMPARE(routing,current);
 
  1457         QCOMPARE(routing,current);
 
  1583 #endif
 
  1458 #endif
 
  1584         StopDnlink();
 
  1459         StopDnlink();
 
  1585         } 
  1460     }
 
  1586     }
 
  1461 }
 
  1587 
       
  1588 
  1462 
  1589 void QTmsVoipTest::DisplayDevice(QTMSAudioOutput device)
 
  1463 void QTmsVoipTest::DisplayDevice(QTMSAudioOutput device)
 
       
  1464 {
 
       
  1465     qDebug("Current Output:");
 
       
  1466 
       
  1467     switch (device) {
 
       
  1468     case QTMS_AUDIO_OUTPUT_NONE:
 
  1590     {
 
  1469     {
 
  1591     qDebug("Current Output:");
 
  1470         qDebug("none");
 
  1592     
  1471     }
 
  1593     switch (device)
 
  1472         break;
 
  1594         {
 
  1473     case QTMS_AUDIO_OUTPUT_PUBLIC:
 
  1595         case QTMS_AUDIO_OUTPUT_NONE:
 
  1474     {
 
  1596             {
 
  1475         qDebug("Public");
 
  1597             qDebug("none");
 
  1476     }
 
  1598             }
 
  1477         break;
 
  1599             break;
 
  1478     case QTMS_AUDIO_OUTPUT_PRIVATE:
 
  1600         case QTMS_AUDIO_OUTPUT_PUBLIC:
 
  1479     {
 
  1601             {
 
  1480         qDebug("Private");
 
  1602             qDebug("Public");
 
  1481     }
 
  1603             }
 
  1482         break;
 
  1604             break;
 
  1483     default:
 
  1605         case QTMS_AUDIO_OUTPUT_PRIVATE:
 
  1484         break;
 
  1606             {
 
  1485     }
 
  1607             qDebug("Private");
 
  1486 }
 
  1608             }
 
       
  1609             break;
 
       
  1610         default:
 
       
  1611             break;
 
       
  1612         }
 
       
  1613     }
 
       
  1614 
       
  1615 
  1487 
  1616 void QTmsVoipTest::CreateDnlinkDtmf()
 
  1488 void QTmsVoipTest::CreateDnlinkDtmf()
 
  1617     {
 
  1489 {
 
  1618     gint status(QTMS_RESULT_SUCCESS);
 
  1490     gint status(QTMS_RESULT_SUCCESS);
 
  1619     GString* dtmfstring(NULL);
 
  1491     GString* dtmfstring(NULL);
 
  1620 
  1492 
  1621     if (m_Factory && m_Dnlink && !m_Dnlnkdtmf)
 
  1493     if (m_Factory && m_Dnlink && !m_Dnlnkdtmf) {
 
  1622         {
 
       
  1623         m_UpLinkCodec = QTMS_FORMAT_PCM;
 
  1494         m_UpLinkCodec = QTMS_FORMAT_PCM;
 
  1624         m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16DecFormatIntfc);
 
  1495         m_Factory->CreateFormat(QTMS_FORMAT_PCM, m_PCM16DecFormatIntfc);
 
  1625         m_Dnlink->SetFormat(m_PCM16DecFormatIntfc);
 
  1496         m_Dnlink->SetFormat(m_PCM16DecFormatIntfc);
 
  1626 
  1497 
  1627         InitDnlink();
 
  1498         InitDnlink();
 
  1628 
  1499 
  1629         status = m_Factory->CreateDTMF(QTMS_STREAM_DOWNLINK, m_Dnlnkdtmf);
 
  1500         status = m_Factory->CreateDTMF(QTMS_STREAM_DOWNLINK, m_Dnlnkdtmf);
 
  1630 
  1501 
  1631         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1502         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1632 
  1503 
  1633         QSignalSpy dtmfspy(m_Dnlnkdtmf,
 
  1504         QSignalSpy dtmfspy(m_Dnlnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
  1634                 SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
  1635 
  1505 
  1636         QVERIFY( dtmfspy.isValid() );
 
  1506         QVERIFY( dtmfspy.isValid() );
 
  1637 
  1507 
  1638         //QCOMPARE(dtmfspy.count(), 0 );
 
  1508         //QCOMPARE(dtmfspy.count(), 0 );
 
  1639 
  1509 
  1640         connect(m_Dnlnkdtmf,
 
  1510         connect(m_Dnlnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)), this,
 
  1641                 SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)), this,
 
  1511             SLOT(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
  1642                 SLOT(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
  1643 
  1512 
  1644         dtmfstring = g_string_new("4723");
 
  1513         dtmfstring = g_string_new("4723");
 
  1645         status = m_Dnlnkdtmf->SetTone(dtmfstring);
 
  1514         status = m_Dnlnkdtmf->SetTone(dtmfstring);
 
  1646 
  1515 
  1647         m_Dnlnkdtmf->Start();
 
  1516         m_Dnlnkdtmf->Start();
 
  1651 
  1520 
  1652         status = m_Dnlnkdtmf->Stop();
 
  1521         status = m_Dnlnkdtmf->Stop();
 
  1653         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1522         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1654         QTest::qWait(1000);
 
  1523         QTest::qWait(1000);
 
  1655         //QCOMPARE(dtmfspy.count(), 2 );
 
  1524         //QCOMPARE(dtmfspy.count(), 2 );
 
  1656         }
 
  1525     }
 
  1657     }
 
  1526 }
 
  1658 
  1527 
  1659 void QTmsVoipTest::CreateRingTone()
 
  1528 void QTmsVoipTest::CreateRingTone()
 
  1660     {
 
  1529 {
 
  1661 
  1530 
  1662     }
 
  1531 }
 
  1663 
       
  1664 
  1532 
  1665 void QTmsVoipTest::CreateBuffer()
 
  1533 void QTmsVoipTest::CreateBuffer()
 
  1666     {
 
  1534 {
 
  1667     gint status(QTMS_RESULT_SUCCESS);
 
  1535     gint status(QTMS_RESULT_SUCCESS);
 
  1668     if (m_Factory)
 
  1536     if (m_Factory) {
 
  1669         {
 
       
  1670         QTMSBuffer* qtmsbuffer(NULL);
 
  1537         QTMSBuffer* qtmsbuffer(NULL);
 
  1671         QTMSBufferType buftype(QTMS_BUFFER_MEMORY);
 
  1538         QTMSBufferType buftype(QTMS_BUFFER_MEMORY);
 
  1672         guint size(100);
 
  1539         guint size(100);
 
  1673         status = m_Factory->CreateBuffer(QTMS_BUFFER_MEMORY, 
  1540         status = m_Factory->CreateBuffer(QTMS_BUFFER_MEMORY, size, qtmsbuffer);
 
  1674                 size, qtmsbuffer);
 
  1541         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1675         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
  1542         if (qtmsbuffer) {
 
  1676         if (qtmsbuffer)
 
       
  1677             {
 
       
  1678             qtmsbuffer->GetType(buftype);
 
  1543             qtmsbuffer->GetType(buftype);
 
  1679             qtmsbuffer->GetDataSize(size);
 
  1544             qtmsbuffer->GetDataSize(size);
 
  1680             qtmsbuffer->SetDataSize(size);
 
  1545             qtmsbuffer->SetDataSize(size);
 
  1681             guint8* pbuf(NULL);
 
  1546             guint8* pbuf(NULL);
 
  1682             qtmsbuffer->GetDataPtr(pbuf);
 
  1547             qtmsbuffer->GetDataPtr(pbuf);
 
  1683             guint64 ts(0);
 
  1548             guint64 ts(0);
 
  1684             qtmsbuffer->GetTimeStamp(ts);
 
  1549             qtmsbuffer->GetTimeStamp(ts);
 
  1685             qtmsbuffer->SetTimeStamp(ts);
 
  1550             qtmsbuffer->SetTimeStamp(ts);
 
  1686             m_Factory->DeleteBuffer(qtmsbuffer);
 
  1551             m_Factory->DeleteBuffer(qtmsbuffer);
 
  1687             }
 
  1552         }
 
  1688         }
 
  1553     }
 
  1689     }
 
  1554 }
 
  1690 
  1555 
  1691 
  1556 void QTmsVoipTest::FillBuffer(QTMSBuffer& buffer)
 
  1692 void QTmsVoipTest::FillBuffer(TMS::TMSBuffer& buffer)
 
  1557 {
 
  1693     {
 
       
  1694     //TODO: add loopback test and file playback
 
  1558     //TODO: add loopback test and file playback
 
  1695 #ifdef  __TEST_CODE_COVERAGE__
 
  1559 #ifdef  __TEST_CODE_COVERAGE__
 
  1696     if(m_ClientSource)
 
  1560     if (m_ClientSource) {
 
  1697         {
 
  1561         static_cast<QTMSClientSource*> (m_ClientSource)->BufferFilled(buffer);
 
  1698         static_cast<QTMSClientSource*> (m_ClientSource)->BufferFilled(
 
  1562     }
 
  1699              buffer);     
       
  1700         }
 
       
  1701 #endif
 
  1563 #endif
 
  1702     
  1564 
  1703     }
 
  1565 }
 
  1704 
  1566 
  1705 void QTmsVoipTest::BufferProcessed(TMS::TMSBuffer* /*buffer*/, gint /*reason*/)
 
  1567 void QTmsVoipTest::BufferProcessed(QTMSBuffer* /*buffer*/, gint /*reason*/)
 
  1706     {
 
  1568 {
 
  1707     }
 
  1569 }
 
  1708 
  1570 
  1709 void QTmsVoipTest::ProcessBuffer(const TMS::TMSBuffer* buffer)
 
  1571 void QTmsVoipTest::ProcessBuffer(const QTMSBuffer* buffer)
 
  1710     {
 
  1572 {
 
  1711     //TODO: add loopback test
 
  1573     //TODO: add loopback test
 
  1712 #ifdef  __TEST_CODE_COVERAGE__    
  1574 #ifdef  __TEST_CODE_COVERAGE__    
  1713     TMS::TMSBuffer* recBuf(NULL);    
  1575     QTMSBuffer* recBuf(NULL);
 
  1714     recBuf = const_cast<TMS::TMSBuffer*> (buffer);  
  1576     recBuf = const_cast<QTMS::QTMSBuffer*> (buffer);
 
  1715     if(m_ClientSink)
 
  1577     if (m_ClientSink) {
 
  1716         {
 
  1578         static_cast<QTMSClientSink*> (m_ClientSink)->BufferProcessed(recBuf);
 
  1717         static_cast<QTMSClientSink*> (m_ClientSink)->BufferProcessed(
 
  1579     }
 
  1718               recBuf);
 
       
  1719         }
 
       
  1720 #endif
 
  1580 #endif
 
  1721     }
 
  1581 }
 
  1722 
  1582 
  1723 
  1583 void QTmsVoipTest::EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event)
 
  1724 
  1584 {
 
  1725 void QTmsVoipTest::EffectsEvent(const QTMSEffect& tmseffect,
 
       
  1726         QTMSSignalEvent event)
 
       
  1727     {
 
       
  1728     QTMSEffectType effecttype;
 
  1585     QTMSEffectType effecttype;
 
  1729     const_cast<QTMSEffect&> (tmseffect).GetType(effecttype);
 
  1586     const_cast<QTMSEffect&> (tmseffect).GetType(effecttype);
 
  1730 
  1587 
  1731     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1588     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1732 
  1589 
  1733     switch (effecttype)
 
  1590     switch (effecttype) {
 
  1734         {
 
  1591     case QTMS_EFFECT_GLOBAL_VOL:
 
  1735         case QTMS_EFFECT_GLOBAL_VOL:
 
  1592     {
 
  1736             {
 
  1593         switch (event.type) {
 
  1737             switch (event.type)
 
  1594         case QTMS_EVENT_EFFECT_VOL_CHANGED:
 
  1738                 {
 
  1595             qDebug("Global vol effect change");
 
  1739                 case QTMS_EVENT_EFFECT_VOL_CHANGED:
 
       
  1740                     qDebug("Global vol effect change");
 
       
  1741                     break;
 
       
  1742                 default:
 
       
  1743                     break;
 
       
  1744                 }
 
       
  1745             }
 
       
  1746             break;
 
       
  1747         case QTMS_EFFECT_GLOBAL_GAIN:
 
       
  1748             {
 
       
  1749             switch (event.type)
 
       
  1750                 {
 
       
  1751                 case QTMS_EVENT_EFFECT_GAIN_CHANGED:
 
       
  1752                     qDebug("Global gain effect change");
 
       
  1753                     break;
 
       
  1754                 default:
 
       
  1755                     break;
 
       
  1756                 }
 
       
  1757             }
 
       
  1758             break;
 
       
  1759         case QTMS_EFFECT_VOLUME:
 
       
  1760             {
 
       
  1761             switch (event.type)
 
       
  1762                 {
 
       
  1763                 case QTMS_EVENT_EFFECT_GAIN_CHANGED:
 
       
  1764                     qDebug("Stream vol effect change");
 
       
  1765                     break;
 
       
  1766                 default:
 
       
  1767                     break;
 
       
  1768                 }
 
       
  1769             }
 
       
  1770             break;
 
       
  1771         case QTMS_EFFECT_GAIN:
 
       
  1772             {
 
       
  1773             switch (event.type)
 
       
  1774                 {
 
       
  1775                 case QTMS_EVENT_EFFECT_GAIN_CHANGED:
 
       
  1776                     qDebug("Stream gain effect change");
 
       
  1777                     break;
 
       
  1778                 default:
 
       
  1779                     break;
 
       
  1780                 }
 
       
  1781             }
 
       
  1782             break;
 
  1596             break;
 
  1783         default:
 
  1597         default:
 
  1784             break;
 
  1598             break;
 
  1785         }
 
  1599         }
 
  1786     }
 
  1600     }
 
  1787  
  1601         break;
 
  1788 
  1602     case QTMS_EFFECT_GLOBAL_GAIN:
 
  1789 
       
  1790 void QTmsVoipTest::GlobalRoutingEvent(const QTMSGlobalRouting& /*routing*/,
 
       
  1791         QTMSSignalEvent event, QTMSAudioOutput /*output*/)
 
       
  1792     {
 
  1603     {
 
       
  1604         switch (event.type) {
 
       
  1605         case QTMS_EVENT_EFFECT_GAIN_CHANGED:
 
       
  1606             qDebug("Global gain effect change");
 
       
  1607             break;
 
       
  1608         default:
 
       
  1609             break;
 
       
  1610         }
 
       
  1611     }
 
       
  1612         break;
 
       
  1613     case QTMS_EFFECT_VOLUME:
 
       
  1614     {
 
       
  1615         switch (event.type) {
 
       
  1616         case QTMS_EVENT_EFFECT_GAIN_CHANGED:
 
       
  1617             qDebug("Stream vol effect change");
 
       
  1618             break;
 
       
  1619         default:
 
       
  1620             break;
 
       
  1621         }
 
       
  1622     }
 
       
  1623         break;
 
       
  1624     case QTMS_EFFECT_GAIN:
 
       
  1625     {
 
       
  1626         switch (event.type) {
 
       
  1627         case QTMS_EVENT_EFFECT_GAIN_CHANGED:
 
       
  1628             qDebug("Stream gain effect change");
 
       
  1629             break;
 
       
  1630         default:
 
       
  1631             break;
 
       
  1632         }
 
       
  1633     }
 
       
  1634         break;
 
       
  1635     default:
 
       
  1636         break;
 
       
  1637     }
 
       
  1638 }
 
       
  1639 
       
  1640 void QTmsVoipTest::GlobalRoutingEvent(const QTMSGlobalRouting& /*routing*/, QTMSSignalEvent event,
 
       
  1641     QTMSAudioOutput /*output*/)
 
       
  1642 {
 
  1793     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1643     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1794     switch (event.type)
 
  1644     switch (event.type) {
 
  1795         {
 
  1645     case QTMS_EVENT_ROUTING_AVAIL_OUTPUTS_CHANGED:
 
  1796         case QTMS_EVENT_ROUTING_AVAIL_OUTPUTS_CHANGED:
 
  1646         qDebug("Available outputs changed");
 
  1797             qDebug("Available outputs changed");
 
  1647         break;
 
  1798             break;
 
  1648     case QTMS_EVENT_ROUTING_OUTPUT_CHANGED:
 
  1799         case QTMS_EVENT_ROUTING_OUTPUT_CHANGED:
 
  1649         qDebug("output changed");
 
  1800             qDebug("output changed");
 
  1650         break;
 
  1801             break;
 
  1651     case QTMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE:
 
  1802         case QTMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE:
 
  1652         qDebug("set output complete");
 
  1803             qDebug("set output complete");
 
  1653         break;
 
  1804             break;
 
  1654     default:
 
  1805         default:
 
  1655         break;
 
  1806             break;
 
  1656     }
 
  1807         }
 
  1657 
  1808     
  1658 }
 
  1809     }
 
  1659 
  1810 
  1660 void QTmsVoipTest::TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event)
 
  1811 void QTmsVoipTest::TMSStreamEvent(const QTMSStream& stream,
 
  1661 {
 
  1812         QTMSSignalEvent event)
 
  1662 
  1813     {
 
       
  1814     
       
  1815     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1663     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1816     
  1664 
  1817     gint streamId;
 
  1665     gint streamId;
 
  1818     streamId = const_cast<QTMSStream&> (stream).GetStreamId();
 
  1666     streamId = const_cast<QTMSStream&> (stream).GetStreamId();
 
  1819     qDebug("StreamID %d",streamId);
 
  1667     qDebug("StreamID %d", streamId);
 
  1820     gint state;
 
  1668     gint state;
 
  1821     state = const_cast<QTMSStream&> (stream).GetState();
 
  1669     state = const_cast<QTMSStream&> (stream).GetState();
 
  1822     QVERIFY(state == event.curr_state);
 
  1670     QVERIFY(state == event.curr_state);
 
  1823     
  1671 
  1824     switch (const_cast<QTMSStream&> (stream).GetStreamType())
 
  1672     switch (const_cast<QTMSStream&> (stream).GetStreamType()) {
 
       
  1673     case QTMS_STREAM_UPLINK:
 
       
  1674     {
 
       
  1675         switch (event.type) {
 
       
  1676         case QTMS_EVENT_STREAM_STATE_CHANGED:
 
  1825         {
 
  1677         {
 
  1826         case QTMS_STREAM_UPLINK:
 
  1678             switch (event.curr_state) {
 
       
  1679             case QTMS_STREAM_INITIALIZED:
 
  1827             {
 
  1680             {
 
  1828             switch (event.type)
 
  1681                 qDebug("Uplink initialized ");
 
  1829                 {
 
  1682                 break;
 
  1830                 case QTMS_EVENT_STREAM_STATE_CHANGED:
 
       
  1831                     {
 
       
  1832                     switch (event.curr_state)
 
       
  1833                         {
 
       
  1834                         case QTMS_STREAM_INITIALIZED:
 
       
  1835                             {
 
       
  1836                             qDebug("Uplink initialized ");
 
       
  1837                             break;
 
       
  1838                             }
 
       
  1839                         case QTMS_STREAM_UNINITIALIZED:
 
       
  1840                             qDebug("Uplink uninitialized ");
 
       
  1841                             break;
 
       
  1842                         case QTMS_STREAM_PAUSED:
 
       
  1843                             qDebug("Uplink paused ");
 
       
  1844                             break;
 
       
  1845                         case QTMS_STREAM_STARTED:
 
       
  1846                             qDebug("Uplink started ");
 
       
  1847                             break;
 
       
  1848                         default:
 
       
  1849                             break;
 
       
  1850                         }
 
       
  1851                     break;
 
       
  1852                     }
 
       
  1853                 default:
 
       
  1854                     break;
 
       
  1855                 }
 
       
  1856             break;
 
       
  1857             }
 
  1683             }
 
  1858         case QTMS_STREAM_DOWNLINK:
 
  1684             case QTMS_STREAM_UNINITIALIZED:
 
  1859             {
 
  1685                 qDebug("Uplink uninitialized ");
 
  1860             switch (event.type)
 
  1686                 break;
 
  1861                 {
 
  1687             case QTMS_STREAM_PAUSED:
 
  1862                 case QTMS_EVENT_STREAM_STATE_CHANGED:
 
  1688                 qDebug("Uplink paused ");
 
  1863                     {
 
  1689                 break;
 
  1864                     switch (event.curr_state)
 
  1690             case QTMS_STREAM_STARTED:
 
  1865                         {
 
  1691                 qDebug("Uplink started ");
 
  1866                         case QTMS_STREAM_INITIALIZED:                           
  1692                 break;
 
  1867                             qDebug("Downlink initialized ");
 
  1693             default:
 
  1868                             break;                    
  1694                 break;
 
  1869                         case QTMS_STREAM_UNINITIALIZED:
 
       
  1870                             qDebug("Downlink uninitialized ");
 
       
  1871                             break;
 
       
  1872                         case QTMS_STREAM_PAUSED:
 
       
  1873                             qDebug("Downlink paused ");
 
       
  1874                             break;
 
       
  1875                         case QTMS_STREAM_STARTED:
 
       
  1876                             qDebug("Downlink started ");
 
       
  1877                             break;
 
       
  1878                         default:
 
       
  1879                             break;
 
       
  1880                         }
 
       
  1881                     break;
 
       
  1882                     }
 
       
  1883                 default:
 
       
  1884                     break;
 
       
  1885                 }
 
       
  1886             break;
 
       
  1887             }
 
  1695             }
 
       
  1696             break;
 
       
  1697         }
 
  1888         default:
 
  1698         default:
 
  1889             break;
 
  1699             break;
 
  1890         }
 
  1700         }
 
  1891     }
 
  1701         break;
 
  1892 
  1702     }
 
  1893 
  1703     case QTMS_STREAM_DOWNLINK:
 
  1894 void QTmsVoipTest::RingtoneEvent(const QTMSRingTone& /*rt*/,
 
       
  1895         QTMSSignalEvent event)
 
       
  1896     {
 
  1704     {
 
       
  1705         switch (event.type) {
 
       
  1706         case QTMS_EVENT_STREAM_STATE_CHANGED:
 
       
  1707         {
 
       
  1708             switch (event.curr_state) {
 
       
  1709             case QTMS_STREAM_INITIALIZED:
 
       
  1710                 qDebug("Downlink initialized ");
 
       
  1711                 break;
 
       
  1712             case QTMS_STREAM_UNINITIALIZED:
 
       
  1713                 qDebug("Downlink uninitialized ");
 
       
  1714                 break;
 
       
  1715             case QTMS_STREAM_PAUSED:
 
       
  1716                 qDebug("Downlink paused ");
 
       
  1717                 break;
 
       
  1718             case QTMS_STREAM_STARTED:
 
       
  1719                 qDebug("Downlink started ");
 
       
  1720                 break;
 
       
  1721             default:
 
       
  1722                 break;
 
       
  1723             }
 
       
  1724             break;
 
       
  1725         }
 
       
  1726         default:
 
       
  1727             break;
 
       
  1728         }
 
       
  1729         break;
 
       
  1730     }
 
       
  1731     default:
 
       
  1732         break;
 
       
  1733     }
 
       
  1734 }
 
       
  1735 
       
  1736 void QTmsVoipTest::RingtoneEvent(const QTMSRingTone& /*rt*/, QTMSSignalEvent event)
 
       
  1737 {
 
  1897     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1738     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1898     switch (event.type)
 
  1739     switch (event.type) {
 
  1899         {
 
  1740     case QTMS_EVENT_RINGTONE_OPEN_COMPLETE:
 
  1900         case QTMS_EVENT_RINGTONE_OPEN_COMPLETE:
 
  1741         qDebug("RT Open Complete");
 
  1901             qDebug("RT Open Complete");
 
  1742         break;
 
  1902             break;
 
  1743     case QTMS_EVENT_RINGTONE_PLAY_COMPLETE:
 
  1903         case QTMS_EVENT_RINGTONE_PLAY_COMPLETE:
 
  1744         qDebug("RT Play Complete");
 
  1904             qDebug("RT Play Complete");
 
  1745         break;
 
  1905             break;
 
  1746     default:
 
  1906         default:
 
  1747         break;
 
  1907             break;
 
  1748     }
 
  1908         }
 
  1749 }
 
  1909     }
 
       
  1910 
       
  1911 
  1750 
  1912 void QTmsVoipTest::DTMFEvent(const QTMSDTMF& /*dtmf*/, QTMSSignalEvent event)
 
  1751 void QTmsVoipTest::DTMFEvent(const QTMSDTMF& /*dtmf*/, QTMSSignalEvent event)
 
  1913     {
 
  1752 {
 
  1914     
  1753 
  1915     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1754     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1916     switch (event.type)
 
  1755     switch (event.type) {
 
  1917         {
 
  1756     case QTMS_EVENT_DTMF_TONE_STARTED:
 
  1918         case QTMS_EVENT_DTMF_TONE_STARTED:
 
  1757         qDebug("DTMF Started");
 
  1919             qDebug("DTMF Started");
 
  1758         break;
 
  1920             break;
 
  1759     case QTMS_EVENT_DTMF_TONE_STOPPED:
 
  1921         case QTMS_EVENT_DTMF_TONE_STOPPED:
 
  1760         qDebug("DTMF Stopped");
 
  1922             qDebug("DTMF Stopped");
 
  1761         break;
 
  1923             break;
 
  1762     default:
 
  1924         default:
 
  1763         break;
 
  1925             break;
 
  1764     }
 
  1926         }
 
  1765 }
 
  1927     }
 
       
  1928 
       
  1929 
  1766 
  1930 QTEST_MAIN_S60(QTmsVoipTest)
 
  1767 QTEST_MAIN_S60(QTmsVoipTest)
 
  1931 
  1768 
  1932 #include "qtmsvoiptest.moc"
 
  1769 #include "qtmsvoiptest.moc"
 
  1933 
  1770
FCL/sf/mw/mmappfw