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         QTMSSourceType qsrctype;

    60         TMSSource* tmssource(NULL);

    61 

    62         qsource->GetType(qsrctype);

    63 

    64         switch (qsrctype) {

    65         case QTMS_SOURCE_CLIENT:

    66             status = static_cast<QTMSClientSourceImpl*> (qsource)->GetSource(tmssource);

    67             break;

    68         case QTMS_SOURCE_MODEM:

    69             status = static_cast<QTMSModemSourceImpl*> (qsource)->GetSource(tmssource);

    70             break;

    71         case QTMS_SOURCE_MIC:

    72             status = static_cast<QTMSMicSourceImpl*> (qsource)->GetSource(tmssource);

    73             break;

    74         default:

    75             break;

    76         }

    77         if (status == QTMS_RESULT_SUCCESS && tmssource) {

    78             status = iStream->AddSource(tmssource);

    79         }

    80     }

    81     return status;

    82 }

    83 

    84 gint QTMSStream::RemoveSource(QTMSSource* qsource)

    85 {

    86     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

    87 

    88     if (iStream && qsource) {

    89         QTMSSourceType qsrctype;

    90         TMSSource* tmssource(NULL);

    91 

    92         qsource->GetType(qsrctype);

    93 

    94         switch (qsrctype) {

    95         case QTMS_SOURCE_CLIENT:

    96             status = static_cast<QTMSClientSourceImpl*> (qsource)->GetSource(tmssource);

    97             break;

    98         case QTMS_SOURCE_MODEM:

    99             status = static_cast<QTMSModemSourceImpl*> (qsource)->GetSource(tmssource);

   100             break;

   101         case QTMS_SOURCE_MIC:

   102             status = static_cast<QTMSMicSourceImpl*> (qsource)->GetSource(tmssource);

   103             break;

   104         default:

   105             break;

   106         }

   107         if (status == QTMS_RESULT_SUCCESS && tmssource) {

   108             status = iStream->RemoveSource(tmssource);

   109         }

   110     }

   111 

   112     return status;

   113 }

   114 

   115 gint QTMSStream::AddSink(QTMSSink* qsink)

   116 {

   117     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   118 

   119     if (iStream && qsink) {

   120         QTMSSinkType qsinktype;

   121         TMSSink* tmssink(NULL);

   122 

   123         qsink->GetType(qsinktype);

   124 

   125         switch (qsinktype) {

   126         case QTMS_SINK_CLIENT:

   127             status = static_cast<QTMSClientSinkImpl*> (qsink)->GetSink(tmssink);

   128             break;

   129         case QTMS_SINK_MODEM:

   130             status = static_cast<QTMSModemSinkImpl*> (qsink)->GetSink(tmssink);

   131             break;

   132         case QTMS_SINK_SPEAKER:

   133             status = static_cast<QTMSSpeakerSinkImpl*> (qsink)->GetSink(tmssink);

   134             break;

   135         default:

   136             break;

   137         }

   138         if (status == QTMS_RESULT_SUCCESS && tmssink) {

   139             status = iStream->AddSink(tmssink);

   140         }

   141     }

   142     return status;

   143 }

   144 

   145 gint QTMSStream::RemoveSink(QTMSSink* qsink)

   146 {

   147     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   148 

   149     if (iStream && qsink) {

   150         QTMSSinkType qsinktype;

   151         TMSSink* tmssink(NULL);

   152 

   153         qsink->GetType(qsinktype);

   154 

   155         switch (qsinktype) {

   156         case QTMS_SINK_CLIENT:

   157             status = static_cast<QTMSClientSinkImpl*> (qsink)->GetSink(tmssink);

   158             break;

   159         case QTMS_SINK_MODEM:

   160             status = static_cast<QTMSModemSinkImpl*> (qsink)->GetSink(tmssink);

   161             break;

   162         case QTMS_SINK_SPEAKER:

   163             status = static_cast<QTMSSpeakerSinkImpl*> (qsink)->GetSink(tmssink);

   164             break;

   165         default:

   166             break;

   167         }

   168         if (status == QTMS_RESULT_SUCCESS && tmssink) {

   169             status = iStream->RemoveSink(tmssink);

   170         }

   171     }

   172 

   173     return status;

   174 }

   175 

   176 gint QTMSStream::SetFormat(QTMSFormat* qformat)

   177 {

   178     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   179 

   180     if (iStream && qformat) {

   181         QTMSFormatType fmttype;

   182         TMSFormat* tmsformat(NULL);

   183         qformat->GetType(fmttype);

   184         switch (fmttype) {

   185         case QTMS_FORMAT_PCM:

   186             status = static_cast<QTMSPCMFormatImpl*> (qformat)->GetFormat(tmsformat);

   187             break;

   188         case QTMS_FORMAT_AMR:

   189             status = static_cast<QTMSAMRFormatImpl*> (qformat)->GetFormat(tmsformat);

   190             break;

   191         case QTMS_FORMAT_G711:

   192             status = static_cast<QTMSG711FormatImpl*> (qformat)->GetFormat(tmsformat);

   193             break;

   194         case QTMS_FORMAT_G729:

   195             status = static_cast<QTMSG729FormatImpl*> (qformat)->GetFormat(tmsformat);

   196             break;

   197         case QTMS_FORMAT_ILBC:

   198             status = static_cast<QTMSILBCFormatImpl*> (qformat)->GetFormat(tmsformat);

   199             break;

   200         default:

   201             break;

   202         }

   203 

   204         status = iStream->SetFormat(tmsformat);

   205     }

   206     return status;

   207 }

   208 

   209 gint QTMSStream::ResetFormat(QTMSFormat* qformat)

   210 {

   211     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   212 

   213     if (iStream && qformat) {

   214         QTMSFormatType fmttype;

   215         TMSFormat* tmsformat(NULL);

   216         qformat->GetType(fmttype);

   217         switch (fmttype) {

   218         case QTMS_FORMAT_PCM:

   219             status = static_cast<QTMSPCMFormatImpl*> (qformat)->GetFormat(tmsformat);

   220             break;

   221         case QTMS_FORMAT_AMR:

   222             status = static_cast<QTMSAMRFormatImpl*> (qformat)->GetFormat(tmsformat);

   223             break;

   224         case QTMS_FORMAT_G711:

   225             status = static_cast<QTMSG711FormatImpl*> (qformat)->GetFormat(tmsformat);

   226             break;

   227         case QTMS_FORMAT_G729:

   228             status = static_cast<QTMSG729FormatImpl*> (qformat)->GetFormat(tmsformat);

   229             break;

   230         case QTMS_FORMAT_ILBC:

   231             status = static_cast<QTMSILBCFormatImpl*> (qformat)->GetFormat(tmsformat);

   232             break;

   233         default:

   234             break;

   235         }

   236 

   237         status = iStream->ResetFormat(tmsformat);

   238     }

   239     return status;

   240 }

   241 

   242 gint QTMSStream::AddEffect(QTMSEffect* qeffect)

   243 {

   244     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   245     if (iStream && qeffect) {

   246         QTMSEffectType effecttype;

   247         TMSEffect* tmseffect(NULL);

   248         qeffect->GetType(effecttype);

   249 

   250         switch (effecttype) {

   251         case QTMS_EFFECT_VOLUME:

   252             status = static_cast<QTMSVolumeEffectImpl*> (qeffect)->GetEffect(tmseffect);

   253             break;

   254         case QTMS_EFFECT_GAIN:

   255             status = static_cast<QTMSGainEffectImpl*> (qeffect)->GetEffect(tmseffect);

   256             break;

   257         default:

   258             break;

   259         }

   260         status = iStream->AddEffect(tmseffect);

   261     }

   262     return status;

   263 }

   264 

   265 gint QTMSStream::RemoveEffect(QTMSEffect* qeffect)

   266 {

   267     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   268     if (iStream && qeffect) {

   269         QTMSEffectType effecttype;

   270         TMSEffect* tmseffect(NULL);

   271         qeffect->GetType(effecttype);

   272 

   273         switch (effecttype) {

   274         case QTMS_EFFECT_VOLUME:

   275             status = static_cast<QTMSVolumeEffectImpl*> (qeffect)->GetEffect(tmseffect);

   276             break;

   277         case QTMS_EFFECT_GAIN:

   278             status = static_cast<QTMSGainEffectImpl*> (qeffect)->GetEffect(tmseffect);

   279             break;

   280         default:

   281             break;

   282         }

   283         status = iStream->RemoveEffect(tmseffect);

   284     }

   285     return status;

   286 }

   287 

   288 gint QTMSStream::GetState()

   289 {

   290     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   291     if (iStream) {

   292         status = iStream->GetState();

   293     }

   294     return status;

   295 }

   296 

   297 gint QTMSStream::GetStreamType()

   298 {

   299     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   300     if (iStream) {

   301         status = iStream->GetStreamType();

   302     }

   303     return status;

   304 }

   305 

   306 gint QTMSStream::GetStreamId()

   307 {

   308     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   309     if (iStream) {

   310         status = iStream->GetStreamId();

   311     }

   312     return status;

   313 }

   314 

   315 gint QTMSStream::Init(gint retrytime)

   316 {

   317     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   318     if (iStream) {

   319         status = iStream->Init(retrytime);

   320     }

   321     return status;

   322 }

   323 

   324 gint QTMSStream::Pause()

   325 {

   326     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   327     if (iStream) {

   328         status = iStream->Pause();

   329     }

   330     return status;

   331 }

   332 

   333 gint QTMSStream::Start(gint retrytime)

   334 {

   335     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   336     if (iStream) {

   337         status = iStream->Start(retrytime);

   338     }

   339     return status;

   340 }

   341 

   342 gint QTMSStream::Stop()

   343 {

   344     gint status(QTMS_RESULT_UNINITIALIZED_OBJECT);

   345     if (iStream) {

   346         status = iStream->Stop();

   347     }

   348     return status;

   349 }

   350 

   351 void QTMSStream::Deinit()

   352 {

   353     if (iStream) {

   354         iStream->Deinit();

   355     }

   356 }

   357