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 <tmssource.h>

    19 #include <tmsformat.h>

    20 #include <tmsstream.h>

    21 #include <qtmseffect.h>

    22 #include <qtmsstream.h>

    23 #include "qtmsstreamimpl.h"

    24 #include "qtmssource.h"

    25 #include "qtmsclientsourceimpl.h"

    26 #include "qtmsmodemsourceimpl.h"

    27 #include "qtmsmicsourceimpl.h"

    28 #include "qtmsclientsinkimpl.h"

    29 #include "qtmsmodemsinkimpl.h"

    30 #include "qtmsspeakersinkimpl.h"

    31 #include "qtmspcmimpl.h"

    32 #include "qtmsamrimpl.h"

    33 #include "qtmsg711impl.h"

    34 #include "qtmsg729impl.h"

    35 #include "qtmsilbcimpl.h"

    36 #include "qtmsvolumeeffectimpl.h"

    37 #include "qtmsgaineffectimpl.h"

    38 #include "qtmswrapperexport.h"

    39 

    40 using namespace QTMS;

    41 using namespace TMS;

    42 

    43 QTMSStream::QTMSStream(void) :

    44     iStream(NULL)

    45     {

    46     }

    47 

    48 QTMSStream::~QTMSStream()

    49     {

    50     //delete iStream;

    51     //delete (static_cast<QTMSStreamImpl*> (iStream));

    52     }

    53 

    54 gint QTMSStream::AddSource(QTMSSource* qsource)

    55     {

    56     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

    57 

    58     if (iStream && qsource)

    59         {

    60         QTMSSourceType qsrctype;

    61         TMSSource* tmssource(NULL);

    62 

    63         qsource->GetType(qsrctype);

    64 

    65         switch (qsrctype)

    66             {

    67             case QTMS_SOURCE_CLIENT:

    68                 status = static_cast<QTMSClientSourceImpl*>

    69                     (qsource)->GetSource(tmssource);

    70                 break;

    71             case QTMS_SOURCE_MODEM:

    72                 status = static_cast<QTMSModemSourceImpl*>

    73                     (qsource)->GetSource(tmssource);

    74                 break;

    75             case QTMS_SOURCE_MIC:

    76                 status = static_cast<QTMSMicSourceImpl*>

    77                     (qsource)->GetSource(tmssource);

    78                 break;

    79             default:

    80                 break;

    81             }

    82         if (status == QTMS_RESULT_SUCCESS && tmssource)

    83             {

    84             status = iStream->AddSource(tmssource);

    85             }

    86         }

    87     return status;

    88     }

    89 

    90 gint QTMSStream::RemoveSource(QTMSSource* qsource)

    91     {

    92     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

    93 

    94     if (iStream && qsource)

    95         {

    96         QTMSSourceType qsrctype;

    97         TMSSource* tmssource(NULL);

    98 

    99         qsource->GetType(qsrctype);

   100 

   101         switch (qsrctype)

   102             {

   103             case QTMS_SOURCE_CLIENT:

   104                 status = static_cast<QTMSClientSourceImpl*>

   105                     (qsource)->GetSource(tmssource);

   106                 break;

   107             case QTMS_SOURCE_MODEM:

   108                 status = static_cast<QTMSModemSourceImpl*>

   109                     (qsource)->GetSource(tmssource);

   110                 break;

   111             case QTMS_SOURCE_MIC:

   112                 status = static_cast<QTMSMicSourceImpl*>

   113                     (qsource)->GetSource(tmssource);

   114                 break;

   115             default:

   116                 break;

   117             }

   118         if (status == QTMS_RESULT_SUCCESS && tmssource)

   119             {

   120             status = iStream->RemoveSource(tmssource);

   121             }

   122         }

   123 

   124     return status;

   125     }

   126 

   127 gint QTMSStream::AddSink(QTMSSink* qsink)

   128     {

   129     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   130 

   131     if (iStream && qsink)

   132         {

   133         QTMSSinkType qsinktype;

   134         TMSSink* tmssink(NULL);

   135 

   136         qsink->GetType(qsinktype);

   137 

   138         switch (qsinktype)

   139             {

   140             case QTMS_SINK_CLIENT:

   141                 status = static_cast<QTMSClientSinkImpl*>

   142                     (qsink)->GetSink(tmssink);

   143                 break;

   144             case QTMS_SINK_MODEM:

   145                 status = static_cast<QTMSModemSinkImpl*>

   146                     (qsink)->GetSink(tmssink);

   147                 break;

   148             case QTMS_SINK_SPEAKER:

   149                 status = static_cast<QTMSSpeakerSinkImpl*>

   150                     (qsink)->GetSink(tmssink);

   151                 break;

   152             default:

   153                 break;

   154             }

   155         if (status == QTMS_RESULT_SUCCESS && tmssink)

   156             {

   157             status = iStream->AddSink(tmssink);

   158             }

   159         }

   160     return status;

   161     }

   162 

   163 gint QTMSStream::RemoveSink(QTMSSink* qsink)

   164     {

   165     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   166 

   167     if (iStream && qsink)

   168         {

   169         QTMSSinkType qsinktype;

   170         TMSSink* tmssink(NULL);

   171 

   172         qsink->GetType(qsinktype);

   173 

   174         switch (qsinktype)

   175             {

   176             case QTMS_SINK_CLIENT:

   177                 status = static_cast<QTMSClientSinkImpl*>

   178                     (qsink)->GetSink(tmssink);

   179                 break;

   180             case QTMS_SINK_MODEM:

   181                 status = static_cast<QTMSModemSinkImpl*>

   182                     (qsink)->GetSink(tmssink);

   183                 break;

   184             case QTMS_SINK_SPEAKER:

   185                 status = static_cast<QTMSSpeakerSinkImpl*>

   186                     (qsink)->GetSink(tmssink);

   187                 break;

   188             default:

   189                 break;

   190             }

   191         if (status == QTMS_RESULT_SUCCESS && tmssink)

   192             {

   193             status = iStream->RemoveSink(tmssink);

   194             }

   195         }

   196 

   197     return status;

   198     }

   199 

   200 gint QTMSStream::SetFormat(QTMSFormat* qformat)

   201     {

   202     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   203 

   204     if (iStream && qformat)

   205         {

   206         QTMSFormatType fmttype;

   207         TMSFormat* tmsformat(NULL);

   208         qformat->GetType(fmttype);

   209         switch (fmttype)

   210             {

   211             case QTMS_FORMAT_PCM:

   212                 status = static_cast<QTMSPCMFormatImpl*>

   213                     (qformat)->GetFormat(tmsformat);

   214                 break;

   215             case QTMS_FORMAT_AMR:

   216                 status = static_cast<QTMSAMRFormatImpl*>

   217                     (qformat)->GetFormat(tmsformat);

   218                 break;

   219             case QTMS_FORMAT_G711:

   220                 status = static_cast<QTMSG711FormatImpl*>

   221                     (qformat)->GetFormat(tmsformat);

   222                 break;

   223             case QTMS_FORMAT_G729:

   224                 status = static_cast<QTMSG729FormatImpl*>

   225                     (qformat)->GetFormat(tmsformat);

   226                 break;

   227             case QTMS_FORMAT_ILBC:

   228                 status = static_cast<QTMSILBCFormatImpl*>

   229                     (qformat)->GetFormat(tmsformat);

   230                 break;

   231             default:

   232                 break;

   233             }

   234 

   235         status = iStream->SetFormat(tmsformat);

   236         }

   237     return status;

   238     }

   239 

   240 gint QTMSStream::ResetFormat(QTMSFormat* qformat)

   241     {

   242     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   243 

   244     if (iStream && qformat)

   245         {

   246         QTMSFormatType fmttype;

   247         TMSFormat* tmsformat(NULL);

   248         qformat->GetType(fmttype);

   249         switch (fmttype)

   250             {

   251             case QTMS_FORMAT_PCM:

   252                 status = static_cast<QTMSPCMFormatImpl*>

   253                     (qformat)->GetFormat(tmsformat);

   254                 break;

   255             case QTMS_FORMAT_AMR:

   256                 status = static_cast<QTMSAMRFormatImpl*>

   257                     (qformat)->GetFormat(tmsformat);

   258                 break;

   259             case QTMS_FORMAT_G711:

   260                 status = static_cast<QTMSG711FormatImpl*>

   261                     (qformat)->GetFormat(tmsformat);

   262                 break;

   263             case QTMS_FORMAT_G729:

   264                 status = static_cast<QTMSG729FormatImpl*>

   265                     (qformat)->GetFormat(tmsformat);

   266                 break;

   267             case QTMS_FORMAT_ILBC:

   268                 status = static_cast<QTMSILBCFormatImpl*>

   269                     (qformat)->GetFormat(tmsformat);

   270                 break;

   271             default:

   272                 break;

   273             }

   274 

   275         status = iStream->ResetFormat(tmsformat);

   276         }

   277     return status;

   278     }

   279 

   280 gint QTMSStream::AddEffect(QTMSEffect* qeffect)

   281     {

   282     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   283     if (iStream && qeffect)

   284         {

   285         QTMSEffectType effecttype;

   286         TMSEffect* tmseffect(NULL);

   287         qeffect->GetType(effecttype);

   288 

   289         switch (effecttype)

   290             {

   291             case QTMS_EFFECT_VOLUME:

   292                 status = static_cast<QTMSVolumeEffectImpl*>

   293                     (qeffect)->GetEffect(tmseffect);

   294                 break;

   295             case QTMS_EFFECT_GAIN:

   296                 status = static_cast<QTMSGainEffectImpl*>

   297                     (qeffect)->GetEffect(tmseffect);

   298                 break;

   299             default:

   300                 break;

   301             }

   302         status = iStream->AddEffect(tmseffect);

   303         }

   304     return status;

   305     }

   306 

   307 gint QTMSStream::RemoveEffect(QTMSEffect* qeffect)

   308     {

   309     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   310     if (iStream && qeffect)

   311         {

   312         QTMSEffectType effecttype;

   313         TMSEffect* tmseffect(NULL);

   314         qeffect->GetType(effecttype);

   315 

   316         switch (effecttype)

   317             {

   318             case QTMS_EFFECT_VOLUME:

   319                 status = static_cast<QTMSVolumeEffectImpl*>

   320                     (qeffect)->GetEffect(tmseffect);

   321                 break;

   322             case QTMS_EFFECT_GAIN:

   323                 status = static_cast<QTMSGainEffectImpl*>

   324                     (qeffect)->GetEffect(tmseffect);

   325                 break;

   326             default:

   327                 break;

   328             }

   329         status = iStream->RemoveEffect(tmseffect);

   330         }

   331     return status;

   332     }

   333 

   334 gint QTMSStream::GetState()

   335     {

   336     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   337     if (iStream)

   338         {

   339         status = iStream->GetState();

   340         }

   341     return status;

   342     }

   343 

   344 gint QTMSStream::GetStreamType()

   345     {

   346     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   347     if (iStream)

   348         {

   349         status = iStream->GetStreamType();

   350         }

   351     return status;

   352     }

   353 

   354 gint QTMSStream::GetStreamId()

   355     {

   356     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   357     if (iStream)

   358         {

   359         status = iStream->GetStreamId();

   360         }

   361     return status;

   362     }

   363 

   364 gint QTMSStream::Init()

   365     {

   366     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   367     if (iStream)

   368         {

   369         status = iStream->Init();

   370         }

   371     return status;

   372     }

   373 

   374 gint QTMSStream::Pause()

   375     {

   376     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   377     if (iStream)

   378         {

   379         status = iStream->Pause();

   380         }

   381     return status;

   382     }

   383 

   384 gint QTMSStream::Start()

   385     {

   386     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   387     if (iStream)

   388         {

   389         status = iStream->Start();

   390         }

   391     return status;

   392     }

   393 

   394 gint QTMSStream::Stop()

   395     {

   396     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   397     if (iStream)

   398         {

   399         status = iStream->Stop();

   400         }

   401     return status;

   402     }

   403 

   404 void QTMSStream::Deinit()

   405     {

   406     if (iStream)

   407         {

   408         iStream->Deinit();

   409         }

   410     }

   411