1 /*

     2  * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description: QT Bindings for TMS

    15  *

    16  */

    17 

    18 #include <tms.h>

    19 #include <tmsfactory.h>

    20 #include <tmsformat.h>

    21 #include <qtms.h>

    22 #include <qtmscall.h>

    23 #include <qtmsformat.h>

    24 #include <qtmseffect.h>

    25 #include <qtmsbuffer.h>

    26 #include <qtmssource.h>

    27 #include <qtmssink.h>

    28 #include <qtmsringtone.h>

    29 #include <qtmsdtmf.h>

    30 #include <qtmsinbandtone.h>

    31 #include "tmsutility.h"

    32 #include "qtmscallimpl.h"

    33 #include "qtmsglobalroutingimpl.h"

    34 #include "qtmsglobalvoleffectimpl.h"

    35 #include "qtmsglobalgaineffectimpl.h"

    36 #include "qtmsvolumeeffectimpl.h"

    37 #include "qtmsgaineffectimpl.h"

    38 #include "qtmsclientsinkimpl.h"

    39 #include "qtmsmodemsinkimpl.h"

    40 #include "qtmsspeakersinkimpl.h"

    41 #include "qtmsclientsourceimpl.h"

    42 #include "qtmsmodemsourceimpl.h"

    43 #include "qtmsmicsourceimpl.h"

    44 #include "qtmsringtoneimpl.h"

    45 #include "qtmsdtmfimpl.h"

    46 #include "qtmsinbandtoneimpl.h"

    47 #include "qtmsfactoryimpl.h"

    48 #include "qtmspcmimpl.h"

    49 #include "qtmsamrimpl.h"

    50 #include "qtmsg711impl.h"

    51 #include "qtmsg729impl.h"

    52 #include "qtmsilbcimpl.h"

    53 #include "qtmsmembuffer.h"

    54 

    55 using namespace QTMS;

    56 using namespace TMS;

    57 

    58 QTMSFactoryImpl::QTMSFactoryImpl()

    59     {

    60     TMSVer* ver = NULL;

    61     TMSFactory::CreateFactory(iFactory, *ver);

    62     }

    63 

    64 QTMSFactoryImpl::~QTMSFactoryImpl()

    65     {

    66     delete iFactory;

    67     }

    68 

    69 gint QTMSFactoryImpl::CreateCall(QTMSCallType ctype, QTMSCall*& qtmscall,

    70         guint /*ctxid*/)

    71     {

    72     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);

    73 

    74     TMSCall* tmscall(NULL);

    75     if (iFactory)

    76         {

    77         ret = iFactory->CreateCall((TMSCallType) ctype, tmscall);

    78 

    79         if (ret == TMS_RESULT_SUCCESS)

    80             {

    81             ret = QTMSCallImpl::Create(qtmscall, tmscall);

    82             }

    83         }

    84     return ret;

    85     }

    86 

    87 gint QTMSFactoryImpl::DeleteCall(QTMSCall*& qtmscall)

    88     {

    89     gint ret(QTMS_RESULT_SUCCESS);

    90     delete qtmscall;

    91     qtmscall = NULL;

    92     return ret;

    93     }

    94 

    95 gint QTMSFactoryImpl::IsCallTypeSupported(QTMSCallType ctype, gboolean& flag)

    96     {

    97     gint ret(QTMS_RESULT_SUCCESS);

    98 

    99     switch (ctype)

   100         {

   101         case QTMS_CALL_CS:

   102         case QTMS_CALL_IP:

   103             flag = ETrue;

   104             break;

   105         case QTMS_CALL_ECS: //from TB 10.1

   106         default:

   107             flag = EFalse;

   108             break;

   109         }

   110     return ret;

   111     }

   112 

   113 gint QTMSFactoryImpl::GetSupportedFormats(const QTMSStreamType strmtype,

   114         FormatVector& fmtlist)

   115     {

   116     gint ret(QTMS_RESULT_SUCCESS);

   117     TMS::FormatVector tmsfmtlist;

   118     if(iFactory)

   119         {

   120         iFactory->GetSupportedFormats(strmtype,tmsfmtlist);

   121         }

   122 

   123     std::vector<TMSFormat*>::iterator itCodecs = tmsfmtlist.begin();

   124     TMSFormatType fmttype;

   125     for (; itCodecs < tmsfmtlist.end(); itCodecs++)

   126         {

   127         (*itCodecs)->GetType(fmttype);

   128         QTMSFormat* qtmsfmt(NULL);

   129         switch (fmttype)

   130             {

   131             case QTMS_FORMAT_PCM:

   132                 ret = QTMSPCMFormatImpl::Create(qtmsfmt,*itCodecs);

   133                 break;

   134             case QTMS_FORMAT_AMR:

   135                 ret = QTMSAMRFormatImpl::Create(qtmsfmt,*itCodecs);

   136                 break;

   137             case QTMS_FORMAT_G711:

   138                 ret = QTMSG711FormatImpl::Create(qtmsfmt,*itCodecs);

   139                 break;

   140             case QTMS_FORMAT_G729:

   141                 ret = QTMSG729FormatImpl::Create(qtmsfmt,*itCodecs);

   142                 break;

   143             case QTMS_FORMAT_ILBC:

   144                 ret = QTMSILBCFormatImpl::Create(qtmsfmt,*itCodecs);

   145                 break;

   146             default:

   147                 break;

   148             }

   149 

   150         if(qtmsfmt)

   151             {

   152             fmtlist.push_back(qtmsfmt);

   153             }

   154         }

   155 

   156     return ret;

   157     }

   158 

   159 gint QTMSFactoryImpl::CreateFormat(QTMSFormatType fmttype,

   160         QTMSFormat*& qtmsfmt)

   161     {

   162     gint ret(QTMS_RESULT_SUCCESS);

   163 

   164     TMSFormat* tmsformat(NULL);

   165 

   166     if (iFactory)

   167         {

   168         ret = iFactory->CreateFormat((TMSFormatType) fmttype, tmsformat);

   169 

   170         if (ret == TMS_RESULT_SUCCESS)

   171             {

   172             switch (fmttype)

   173                 {

   174                 case QTMS_FORMAT_PCM:

   175                     ret = QTMSPCMFormatImpl::Create(qtmsfmt, tmsformat);

   176                     break;

   177                 case QTMS_FORMAT_AMR:

   178                     ret = QTMSAMRFormatImpl::Create(qtmsfmt, tmsformat);

   179                     break;

   180                 case QTMS_FORMAT_G711:

   181                     ret = QTMSG711FormatImpl::Create(qtmsfmt, tmsformat);

   182                     break;

   183                 case QTMS_FORMAT_G729:

   184                     ret = QTMSG729FormatImpl::Create(qtmsfmt, tmsformat);

   185                     break;

   186                 case QTMS_FORMAT_ILBC:

   187                     ret = QTMSILBCFormatImpl::Create(qtmsfmt, tmsformat);

   188                     break;

   189                 default:

   190                     break;

   191                 }

   192             }

   193         }

   194 

   195     return ret;

   196     }

   197 

   198 gint QTMSFactoryImpl::DeleteFormat(QTMSFormat*& qtmsfmt)

   199     {

   200     gint ret(QTMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED);

   201 

   202     QTMSFormatType fmttype;

   203     ret = qtmsfmt->GetType(fmttype);

   204     switch (fmttype)

   205         {

   206         case QTMS_FORMAT_PCM:

   207             delete (static_cast<QTMSPCMFormatImpl*>(qtmsfmt));

   208             qtmsfmt = NULL;

   209             ret = QTMS_RESULT_SUCCESS;

   210             break;

   211         case QTMS_FORMAT_AMR:

   212             delete (static_cast<QTMSAMRFormatImpl*>(qtmsfmt));

   213             qtmsfmt = NULL;

   214             ret = QTMS_RESULT_SUCCESS;

   215             break;

   216         case QTMS_FORMAT_G711:

   217             delete (static_cast<QTMSG711FormatImpl*>(qtmsfmt));

   218             qtmsfmt = NULL;

   219             ret = QTMS_RESULT_SUCCESS;

   220             break;

   221         case QTMS_FORMAT_G729:

   222             delete (static_cast<QTMSG729FormatImpl*>(qtmsfmt));

   223             qtmsfmt = NULL;

   224             ret = QTMS_RESULT_SUCCESS;

   225             break;

   226         case QTMS_FORMAT_ILBC:

   227             delete (static_cast<QTMSILBCFormatImpl*>(qtmsfmt));

   228             qtmsfmt = NULL;

   229             ret = QTMS_RESULT_SUCCESS;

   230             break;

   231         default:

   232             break;

   233         }

   234 

   235     return ret;

   236     }

   237 

   238 gint QTMSFactoryImpl::CreateEffect(QTMSEffectType tmseffecttype,

   239         QTMSEffect*& qtmseffect)

   240     {

   241     //gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);

   242     gint ret(TMS_RESULT_SUCCESS);

   243     TMSEffect* tmseffect(NULL);

   244     if (iFactory)

   245         {

   246         ret = iFactory->CreateEffect((TMSEffectType) tmseffecttype, tmseffect);

   247 

   248         if (ret == TMS_RESULT_SUCCESS)

   249             {

   250             switch (tmseffecttype)

   251                 {

   252                 case TMS_EFFECT_VOLUME:

   253                     ret = QTMSVolumeEffectImpl::Create(qtmseffect, tmseffect);

   254                     break;

   255                 case TMS_EFFECT_GAIN:

   256                     ret = QTMSGainEffectImpl::Create(qtmseffect, tmseffect);

   257                     break;

   258                 case TMS_EFFECT_GLOBAL_VOL:

   259                     ret = QTMSGlobalVolEffectImpl::Create(qtmseffect,

   260                             tmseffect);

   261                     break;

   262                 case TMS_EFFECT_GLOBAL_GAIN:

   263                     ret = QTMSGlobalGainEffectImpl::Create(qtmseffect,

   264                             tmseffect);

   265                     break;

   266                 default:

   267                     ret = TMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED;

   268                     break;

   269                 }

   270             }

   271         }

   272 

   273     return ret;

   274     }

   275 

   276 gint QTMSFactoryImpl::DeleteEffect(QTMSEffect*& qtmseffect)

   277     {

   278     gint ret(QTMS_RESULT_SUCCESS);

   279 

   280     QTMSEffectType effecttype;

   281     ret = qtmseffect->GetType(effecttype);

   282     switch (effecttype)

   283         {

   284         case QTMS_EFFECT_VOLUME:

   285             delete (static_cast<QTMSVolumeEffectImpl*> (qtmseffect));

   286             qtmseffect = NULL;

   287             break;

   288         case QTMS_EFFECT_GAIN:

   289             delete (static_cast<QTMSGainEffectImpl*> (qtmseffect));

   290             qtmseffect = NULL;

   291             break;

   292         case QTMS_EFFECT_GLOBAL_VOL:

   293             delete (static_cast<QTMSGlobalVolEffectImpl*> (qtmseffect));

   294             qtmseffect = NULL;

   295             break;

   296         case QTMS_EFFECT_GLOBAL_GAIN:

   297             delete (static_cast<QTMSGlobalGainEffectImpl*> (qtmseffect));

   298             qtmseffect = NULL;

   299             break;

   300         default:

   301             ret = QTMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED;

   302             break;

   303         }

   304 

   305     return ret;

   306     }

   307 

   308 gint QTMSFactoryImpl::CreateBuffer(QTMSBufferType buffertype, guint size,

   309         QTMSBuffer*& qtmsbuffer)

   310     {

   311     gint ret(TMS_RESULT_INSUFFICIENT_MEMORY);

   312     TRACE_PRN_FN_ENT;

   313 

   314     switch (buffertype)

   315         {

   316         case QTMS_BUFFER_MEMORY:

   317             ret = QTMSMemBuffer::Create(size, qtmsbuffer);

   318             break;

   319         default:

   320             ret = QTMS_RESULT_BUFFER_TYPE_NOT_SUPPORTED;

   321             break;

   322         }

   323 

   324     TRACE_PRN_FN_EXT;

   325     return ret;

   326     }

   327 

   328 gint QTMSFactoryImpl::DeleteBuffer(QTMSBuffer*& qtmsbuffer)

   329     {

   330     delete (static_cast<QTMSMemBuffer*> (qtmsbuffer));

   331     qtmsbuffer = NULL;

   332     return QTMS_RESULT_SUCCESS;

   333     }

   334 

   335 gint QTMSFactoryImpl::CreateSource(QTMSSourceType srctype,

   336         QTMSSource*& qtmssrc)

   337     {

   338     gint ret(QTMS_RESULT_SUCCESS);

   339 

   340     TMS::TMSSource* tmssource(NULL);

   341     if (iFactory)

   342         {

   343         ret = iFactory->CreateSource(srctype, tmssource);

   344 

   345         if (ret == TMS_RESULT_SUCCESS)

   346             {

   347             switch (srctype)

   348                 {

   349                 case QTMS_SOURCE_CLIENT:

   350                     ret = QTMSClientSourceImpl::Create(qtmssrc, tmssource);

   351                     break;

   352                 case QTMS_SOURCE_MODEM:

   353                     ret = QTMSModemSourceImpl::Create(qtmssrc, tmssource);

   354                     break;

   355                 case QTMS_SOURCE_MIC:

   356                     ret = QTMSMicSourceImpl::Create(qtmssrc, tmssource);

   357                     break;

   358                 default:

   359                     break;

   360                 }

   361             }

   362         }

   363 

   364     return ret;

   365     }

   366 

   367 gint QTMSFactoryImpl::DeleteSource(QTMSSource*& qtmssrc)

   368     {

   369     gint ret(TMS_RESULT_INVALID_ARGUMENT);

   370 

   371     QTMSSourceType sourcetype;

   372     ret = qtmssrc->GetType(sourcetype);

   373     switch (sourcetype)

   374         {

   375         case QTMS_SOURCE_CLIENT:

   376             delete (static_cast<QTMSClientSourceImpl*>(qtmssrc));

   377             qtmssrc = NULL;

   378             ret = QTMS_RESULT_SUCCESS;

   379             break;

   380         case QTMS_SOURCE_MODEM:

   381             {

   382             delete (static_cast<QTMSModemSourceImpl*>(qtmssrc));

   383             qtmssrc = NULL;

   384             ret = TMS_RESULT_SUCCESS;

   385             }

   386             break;

   387         case TMS_SOURCE_MIC:

   388             {

   389             delete (static_cast<QTMSMicSourceImpl*>(qtmssrc));

   390             qtmssrc = NULL;

   391             ret = TMS_RESULT_SUCCESS;

   392             }

   393             break;

   394         default:

   395             ret = TMS_RESULT_SOURCE_TYPE_NOT_SUPPORTED;

   396             break;

   397         }

   398 

   399     TRACE_PRN_FN_EXT;

   400     return ret;

   401     }

   402 

   403 gint QTMSFactoryImpl::CreateSink(QTMSSinkType sinktype, QTMSSink*& qtmssink)

   404     {

   405     gint ret(QTMS_RESULT_SUCCESS);

   406 

   407     TMS::TMSSink* tmssink(NULL);

   408 

   409     if (iFactory)

   410         {

   411         ret = iFactory->CreateSink(sinktype, tmssink);

   412 

   413         if (ret == TMS_RESULT_SUCCESS)

   414             {

   415             switch (sinktype)

   416                 {

   417                 case QTMS_SINK_CLIENT:

   418                     ret = QTMSClientSinkImpl::Create(qtmssink, tmssink);

   419                     break;

   420                 case QTMS_SINK_MODEM:

   421                     ret = QTMSModemSinkImpl::Create(qtmssink, tmssink);

   422                     break;

   423                 case QTMS_SINK_SPEAKER:

   424                     ret = QTMSSpeakerSinkImpl::Create(qtmssink, tmssink);

   425                     break;

   426                 default:

   427                     break;

   428                 }

   429             }

   430         }

   431 

   432     return ret;

   433     }

   434 

   435 gint QTMSFactoryImpl::DeleteSink(QTMSSink*& qtmssink)

   436     {

   437     gint ret(QTMS_RESULT_INVALID_ARGUMENT);

   438 

   439     QTMSSinkType sinktype;

   440     ret = qtmssink->GetType(sinktype);

   441     switch (sinktype)

   442         {

   443         case QTMS_SINK_CLIENT:

   444             {

   445             delete (static_cast<QTMSClientSinkImpl*>(qtmssink));

   446             qtmssink = NULL;

   447             ret = QTMS_RESULT_SUCCESS;

   448             }

   449             break;

   450         case QTMS_SINK_MODEM:

   451             {

   452             delete (static_cast<QTMSModemSinkImpl*>(qtmssink));

   453             qtmssink = NULL;

   454             ret = QTMS_RESULT_SUCCESS;

   455             }

   456             break;

   457         case QTMS_SINK_SPEAKER:

   458             {

   459             delete (static_cast<QTMSSpeakerSinkImpl*>(qtmssink));

   460             qtmssink = NULL;

   461             ret = QTMS_RESULT_SUCCESS;

   462             }

   463             break;

   464         default:

   465             ret = QTMS_RESULT_SINK_TYPE_NOT_SUPPORTED;

   466             break;

   467         }

   468 

   469     return ret;

   470     }

   471 

   472 gint QTMSFactoryImpl::CreateGlobalRouting(QTMSGlobalRouting*& qrouting)

   473     {

   474     gint ret(QTMS_RESULT_SUCCESS);

   475 

   476     TMS::TMSGlobalRouting* tmsrouting(NULL);

   477     if (iFactory)

   478         {

   479         ret = iFactory->CreateGlobalRouting(tmsrouting);

   480 

   481         if (ret == TMS_RESULT_SUCCESS)

   482             {

   483             ret = QTMSGlobalRoutingImpl::Create(qrouting, tmsrouting);

   484             }

   485         }

   486     return ret;

   487     }

   488 

   489 gint QTMSFactoryImpl::DeleteGlobalRouting(QTMSGlobalRouting*& globalrouting)

   490     {

   491     gint ret(QTMS_RESULT_SUCCESS);

   492     delete (static_cast<QTMSGlobalRoutingImpl*>(globalrouting));

   493     globalrouting = NULL;

   494     return ret;

   495     }

   496 

   497 gint QTMSFactoryImpl::CreateDTMF(QTMSStreamType streamtype, QTMSDTMF*& qdtmf)

   498     {

   499     gint ret(QTMS_RESULT_SUCCESS);

   500 

   501     TMS::TMSDTMF* tmsdtmf = NULL;

   502 

   503     if (iFactory)

   504         {

   505         ret = iFactory->CreateDTMF(streamtype, tmsdtmf);

   506 

   507         if (ret == TMS_RESULT_SUCCESS)

   508             {

   509             ret = QTMSDTMFImpl::Create(qdtmf, tmsdtmf);

   510             }

   511         }

   512     return ret;

   513     }

   514 

   515 gint QTMSFactoryImpl::DeleteDTMF(QTMSDTMF*& dtmf)

   516     {

   517     gint ret(QTMS_RESULT_SUCCESS);

   518     delete (static_cast<QTMSDTMFImpl*>(dtmf));

   519     dtmf = NULL;

   520     return ret;

   521     }

   522 

   523 gint QTMSFactoryImpl::CreateRingTonePlayer(QTMSRingTone*& rt)

   524     {

   525     gint ret(QTMS_RESULT_SUCCESS);

   526 

   527     TMS::TMSRingTone* tmsrt = NULL;

   528 

   529     if (iFactory)

   530         {

   531         ret = iFactory->CreateRingTonePlayer(tmsrt);

   532 

   533         if (ret == TMS_RESULT_SUCCESS)

   534             {

   535             ret = QTMSRingToneImpl::Create(rt, tmsrt);

   536             }

   537         }

   538     return ret;

   539     }

   540 

   541 gint QTMSFactoryImpl::DeleteRingTonePlayer(QTMSRingTone*& rt)

   542     {

   543     gint ret(QTMS_RESULT_SUCCESS);

   544     delete (static_cast<QTMSRingToneImpl*>(rt));

   545     rt = NULL;

   546     return ret;

   547     }

   548 

   549 gint QTMSFactoryImpl::CreateInbandTonePlayer(QTMSInbandTone*& qinbandtone)

   550     {

   551     gint ret(QTMS_RESULT_SUCCESS);

   552 

   553     TMS::TMSInbandTone* tmsinband = NULL;

   554     if (iFactory)

   555         {

   556         ret = iFactory->CreateInbandTonePlayer(tmsinband);

   557 

   558         if (ret == TMS_RESULT_SUCCESS)

   559             {

   560             ret = QTMSInbandToneImpl::Create(qinbandtone, tmsinband);

   561             }

   562         }

   563     return ret;

   564     }

   565 

   566 gint QTMSFactoryImpl::DeleteInbandTonePlayer(QTMSInbandTone*& inbandtone)

   567     {

   568     gint ret(QTMS_RESULT_SUCCESS);

   569     delete (static_cast<QTMSInbandToneImpl*>(inbandtone));

   570     inbandtone = NULL;

   571     return ret;

   572     }

   573 

   574 // End of file