multimediacommscontroller/mmccsubcontroller/src/mccsymsimpledlstream.cpp
changeset 0 1bce908db942
child 32 f2ed1fc4c163
equal deleted inserted replaced
-1:000000000000 0:1bce908db942
       
     1 /*
       
     2 * Copyright (c) 2006-2008 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:    MCP Symmetric subthread downlink stream
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 // INCLUDE FILES
       
    21 #include <mmf/server/mmfformat.h>
       
    22 #include <mmf/server/mmfaudiooutput.h>
       
    23 #include "mccsymsimpledlstream.h"
       
    24 #include "mccdldatapath.h"
       
    25 #include "mccjitterbuffer.h"
       
    26 #include "mccuids.hrh"
       
    27 #include "mccrtpmanager.h"
       
    28 #include "mcccodecconfigurator.h"
       
    29 #include "mccinternaldef.h"
       
    30 #include "mccvideosink.h"
       
    31 #include "mccsubcontrollerlogs.h"
       
    32 #include "mccmultiplexer.h"
       
    33 #include "mccresources.h"
       
    34 
       
    35 // CONSTANTS
       
    36 
       
    37 // ============================= LOCAL FUNCTIONS ===============================
       
    38 
       
    39 // ============================ MEMBER FUNCTIONS ===============================
       
    40 
       
    41 // -----------------------------------------------------------------------------
       
    42 // CMccSymSimpleDlStream::CMccSymSimpleDlStream
       
    43 // C++ default constructor can NOT contain any code, that
       
    44 // might leave.
       
    45 // -----------------------------------------------------------------------------
       
    46 //
       
    47 CMccSymSimpleDlStream::CMccSymSimpleDlStream( 
       
    48     TUint32 aMccStreamId, 
       
    49     MAsyncEventHandler* aEventhandler, 
       
    50     MMccResources* aMccResources,
       
    51     CMccRtpManager* aManager, 
       
    52     TFourCC aFourCC,
       
    53     TInt aStreamType ) : 
       
    54     CMccSymStreamBase( aMccStreamId, 
       
    55                        aEventhandler, 
       
    56                        aMccResources, 
       
    57                        aManager, 
       
    58                        aStreamType )
       
    59     {
       
    60     iFourCC = aFourCC;
       
    61     }
       
    62 
       
    63 // -----------------------------------------------------------------------------
       
    64 // CMccSymSimpleDlStream::NewL
       
    65 // Two-phased constructor.
       
    66 // -----------------------------------------------------------------------------
       
    67 //
       
    68 CMccSymSimpleDlStream* CMccSymSimpleDlStream::NewLC( 
       
    69     TUint32 aMccStreamId, 
       
    70     MAsyncEventHandler* aEventhandler, 
       
    71     MMccResources* aMccResources,
       
    72     CMccRtpManager* aManager, 
       
    73     TFourCC aFourCC,
       
    74     TInt aStreamType ) 
       
    75     {
       
    76     CMccSymSimpleDlStream* s = 
       
    77             new ( ELeave ) CMccSymSimpleDlStream( aMccStreamId, 
       
    78                                                   aEventhandler,
       
    79                                                   aMccResources, 
       
    80                                                   aManager, 
       
    81                                                   aFourCC, 
       
    82                                                   aStreamType );
       
    83     CleanupStack::PushL( s );
       
    84     s->ConstructL();
       
    85 
       
    86     return s;
       
    87     }
       
    88 
       
    89 // -----------------------------------------------------------------------------
       
    90 // CMccSymSimpleDlStream::ConstructL
       
    91 // Symbian 2nd phase constructor can leave.
       
    92 // -----------------------------------------------------------------------------
       
    93 //
       
    94 void CMccSymSimpleDlStream::ConstructL()
       
    95     {
       
    96     iDatapath = CMccDlDataPath::NewL( this, iMccResources, Type() );
       
    97     }
       
    98 
       
    99 // -----------------------------------------------------------------------------
       
   100 // CMccSymSimpleDlStream::~CMccSymSimpleDlStream
       
   101 // Destructor
       
   102 // -----------------------------------------------------------------------------
       
   103 //
       
   104 CMccSymSimpleDlStream::~CMccSymSimpleDlStream()
       
   105     {
       
   106     if( iSoundDevice )
       
   107         {
       
   108         iSoundDevice = NULL;
       
   109         }
       
   110     
       
   111     // Must do mux cleanup before decoder (mux sink) deletion
       
   112     MultiplexerCleanup();
       
   113         
       
   114     if( iFormatDecode )
       
   115         {
       
   116         iFormatDecode->SourceThreadLogoff();
       
   117         delete iFormatDecode;
       
   118         iFormatDecode = NULL;
       
   119         }
       
   120     }
       
   121 
       
   122 // -----------------------------------------------------------------------------
       
   123 // CMccSymSimpleDlStream::SetPrioritySettingsL
       
   124 // Sets the MMF priority settings for this stream
       
   125 // -----------------------------------------------------------------------------
       
   126 //
       
   127 void CMccSymSimpleDlStream::SetPrioritySettingsL( 
       
   128     const TMMFPrioritySettings& aPriority )
       
   129     {
       
   130     __ASSERT_ALWAYS( iDatasink, User::Leave( KErrNotReady ) ); 
       
   131    
       
   132     iDatasink->SetSinkPrioritySettings( aPriority );
       
   133     }
       
   134 
       
   135 // -----------------------------------------------------------------------------
       
   136 // CMccSymSimpleDlStream::AddSinkAndSourceL
       
   137 // From CMccSymStreamBase
       
   138 // -----------------------------------------------------------------------------
       
   139 //
       
   140 void CMccSymSimpleDlStream::AddSinkAndSourceL( 
       
   141     MDataSink* aDatasink, 
       
   142     MDataSource* aDatasource )
       
   143     {
       
   144     __ASSERT_ALWAYS( aDatasink && aDatasource, User::Leave( KErrArgument ) );
       
   145 
       
   146     iDatasink = aDatasink;
       
   147     iDatasource = aDatasource;    
       
   148     
       
   149     iMultiplexer = iMccResources->MultiplexerL( iDatasource );
       
   150     
       
   151     // Inform datapath about ids of associated sink and source
       
   152     iDatapath->SetAssociatedSink( iDatasink );
       
   153     iDatapath->SetAssociatedSource( iDatasource );
       
   154 	        
       
   155 	iDatapath->AddDataSinkL( aDatasink );
       
   156 
       
   157     User::LeaveIfError( iDatasink->SinkThreadLogon( *this ) );
       
   158 	      
       
   159     iDatapath->AddDataSourceL( aDatasource );		    
       
   160     }
       
   161 
       
   162 // -----------------------------------------------------------------------------
       
   163 // CMccSymSimpleDlStream::LoadCodecL
       
   164 // From CMccSymStreamBase
       
   165 // -----------------------------------------------------------------------------
       
   166 //
       
   167 void CMccSymSimpleDlStream::LoadCodecL( 
       
   168     const TMccCodecInfo& aCodecInfo,
       
   169     const TDesC8& aFmtp )
       
   170     {
       
   171     __SUBCONTROLLER_INT1( "CMccSymSimpleDlStream::LoadCodecL, codec state:", 
       
   172                           CurrentCodecState() )
       
   173     
       
   174     __ASSERT_ALWAYS( CurrentCodecState() == EStateCodecNone || 
       
   175                      iCodecInfo.iFourCC == aCodecInfo.iFourCC,
       
   176                      User::Leave( KErrArgument ) );
       
   177         
       
   178     iCodecInfo = aCodecInfo;
       
   179     
       
   180     if ( CurrentCodecState() == EStateCodecNone )
       
   181         {
       
   182         delete iFmtpAttr;
       
   183         iFmtpAttr = NULL;
       
   184 
       
   185     	iFmtpAttr = HBufC8::NewL( aFmtp.Length() );
       
   186         iFmtpAttr->Des().Copy( aFmtp );
       
   187         
       
   188         iCodecInfo.iFmtpLength = iFmtpAttr->Length();
       
   189         CreatePayloadFormatDecoderL();
       
   190         
       
   191         // Just negotiate the codec, load it later
       
   192         static_cast<CMccDlDataPath*>( iDatapath )->NegotiateL( *iFormatDecode );
       
   193         
       
   194         SetCodecState( EStateCodecNegotiated );        	
       
   195         }
       
   196     else if ( CurrentCodecState() == EStateCodecNegotiated )
       
   197         {
       
   198         // Codec is not fully usable yet, do just formatter initialization
       
   199         MccCodecConfigurator::ConfigureCodecL( *iFormatDecode,
       
   200                                                 *iDatasink,
       
   201                                                 aCodecInfo,
       
   202                                                 *iRtpMediaClock,
       
   203                                                 CurrentCodecState() );
       
   204                                                 
       
   205         MccCodecConfigurator::ConfigureCodecL( *iDatasource,
       
   206                                                 *iDatasink, 
       
   207                                                 iCodecInfo,
       
   208                                                 *iRtpMediaClock,
       
   209                                                 CurrentCodecState() );
       
   210                                                 
       
   211         SetCodecState( EStateCodecPrepared );
       
   212         }
       
   213     else if ( CurrentCodecState() == EStateCodecPrepared )
       
   214         {
       
   215         if ( CodecLoadingAllowed() )
       
   216             {
       
   217             // Load the codec
       
   218             static_cast<CMccDlDataPath*>( iDatapath )->LoadL( *iFormatDecode );
       
   219             
       
   220             // Set state before updating as the state affects to update functionality
       
   221             SetCodecState( EStateCodecLoaded );
       
   222                                                
       
   223             UpdateCodecInformationL( iCodecInfo );
       
   224             }
       
   225         }
       
   226     else if ( CurrentCodecState() == EStateCodecLoaded ||
       
   227               CurrentCodecState() == EStateCodecLoadedAndUpdating )
       
   228         {
       
   229         // Update codec info
       
   230         if ( iDatasource->DataSourceType() == KMccRtpSourceUid )
       
   231        	    {
       
   232             CMccRtpDataSource* dataSource = 
       
   233                 static_cast<CMccRtpDataSource*>( iDatasource );
       
   234             
       
   235             // For updating keep alive parameters
       
   236             TMccCodecInfoBuffer infoBuffer( iCodecInfo );     
       
   237             dataSource->ConfigureL( infoBuffer );
       
   238        	    }
       
   239         SetCodecState( EStateCodecLoadedAndUpdating );
       
   240     	UpdateCodecInformationL( iCodecInfo );
       
   241         }
       
   242     else
       
   243         {
       
   244         User::Leave( KErrNotReady );
       
   245         }
       
   246         
       
   247     __SUBCONTROLLER_INT1( "CMccSymSimpleDlStream::LoadCodecL, exit, new state:", 
       
   248                           CurrentCodecState() )
       
   249     }
       
   250 
       
   251 // -----------------------------------------------------------------------------
       
   252 // CMccSymSimpleDlStream::UpdateCodecInformationL
       
   253 // From CMccSymStreamBase
       
   254 // -----------------------------------------------------------------------------
       
   255 //
       
   256 void CMccSymSimpleDlStream::UpdateCodecInformationL( TMccCodecInfo& aCodecInfo )
       
   257     {
       
   258     __ASSERT_ALWAYS( iFormatDecode, User::Leave( KErrArgument ) );
       
   259     __ASSERT_ALWAYS( iDatasink, User::Leave( KErrArgument ) );
       
   260     __ASSERT_ALWAYS( iDatasource, User::Leave( KErrArgument ) );
       
   261 
       
   262     HandleSpecialSinksAndSources();
       
   263     
       
   264     iCodecInfo.iIsUpdate = ETrue;
       
   265     
       
   266     // Configure the decoder
       
   267     MccCodecConfigurator::ConfigureCodecL( *iFormatDecode,
       
   268                                             *iDatasink, 
       
   269                                             aCodecInfo,
       
   270                                             *iRtpMediaClock,
       
   271                                             CurrentCodecState() );
       
   272     
       
   273     // Configure also the real source
       
   274     MccCodecConfigurator::ConfigureCodecL( *iDatasource,
       
   275                                             *iDatasink, 
       
   276                                             iCodecInfo,
       
   277                                             *iRtpMediaClock,
       
   278                                             CurrentCodecState() );
       
   279     }
       
   280     
       
   281 
       
   282 // -----------------------------------------------------------------------------
       
   283 // CMccSymDlStream::CreatePayloadFormatDecoderL
       
   284 // Creates the payload format decoder
       
   285 // -----------------------------------------------------------------------------
       
   286 //
       
   287 void CMccSymSimpleDlStream::CreatePayloadFormatDecoderL()
       
   288     {
       
   289     __ASSERT_ALWAYS( iMultiplexer, User::Leave( KErrArgument ) );
       
   290 
       
   291     TUid formatuid;
       
   292     CMMFFormatDecode* tmp = NULL;
       
   293     
       
   294     formatuid.iUid = KImplUidAnyPayloadFormatDecode;
       
   295     
       
   296     // Multiplexer is the source of the decoder
       
   297     tmp = CMMFFormatDecode::NewL( formatuid, iMultiplexer );
       
   298     
       
   299 	tmp->SetSourceDataTypeCode( iCodecInfo.iFourCC, Type() );
       
   300 
       
   301     if( iFormatDecode )
       
   302         {
       
   303         // Remove old one from multiplexer
       
   304         iMultiplexer->MultiplexerSourceThreadLogoff( iFormatDecode );
       
   305         
       
   306         iFormatDecode->SourceThreadLogoff();
       
   307         delete iFormatDecode;
       
   308         }
       
   309     
       
   310     iFormatDecode = tmp;
       
   311     User::LeaveIfError( iFormatDecode->SourceThreadLogon( *this ) );
       
   312     
       
   313     // Add decoder as sink of the multiplexer
       
   314     User::LeaveIfError( 
       
   315         iMultiplexer->MultiplexerSourceThreadLogon( *this, *iFormatDecode, ETrue, Type() ) );
       
   316 
       
   317     if ( KMccRtpSourceUid == iDatasource->DataSourceType() )
       
   318         {
       
   319         RArray<TUint> payloads;
       
   320         CleanupClosePushL( payloads );
       
   321         ParsePayloadTypesL( payloads, iCodecInfo );
       
   322         iMultiplexer->RegClientForPayloadsL( *iFormatDecode, payloads );
       
   323         CleanupStack::PopAndDestroy( &payloads );
       
   324         }
       
   325     }
       
   326 
       
   327 // -----------------------------------------------------------------------------
       
   328 // CMccSymDlStream::PrimeL
       
   329 // Primes the audio stream ready
       
   330 // -----------------------------------------------------------------------------
       
   331 //
       
   332 void CMccSymSimpleDlStream::PrimeL( const TUint32 aEndpointId )
       
   333     {
       
   334     __ASSERT_ALWAYS( iRtpmanager, User::Leave( KErrArgument ) );
       
   335     __ASSERT_ALWAYS( iDatapath, User::Leave( KErrArgument ) );
       
   336 
       
   337     TBool controlNetworkResources = SetStateL( EStatePrepared, aEndpointId );
       
   338     
       
   339      if ( controlNetworkResources && !LocalStream() )
       
   340         {
       
   341         iRtpmanager->CreateReceiveStreamL( *iDatasource, iCodecInfo );
       
   342         }
       
   343     
       
   344     LoadCodecL( iCodecInfo, KNullDesC8 );
       
   345     
       
   346     DoPrimeL();
       
   347     
       
   348     InformStreamStateChange( KMccStreamPrepared, aEndpointId );
       
   349     }
       
   350 
       
   351 // -----------------------------------------------------------------------------
       
   352 // CMccSymSimpleDlStream::PlayL
       
   353 // Starts audio streaming
       
   354 // -----------------------------------------------------------------------------
       
   355 //
       
   356 void CMccSymSimpleDlStream::PlayL( 
       
   357     const TUint32 aEndpointId, 
       
   358     TBool /*aStreamPaused*/, 
       
   359     TBool aEnableRtcp )
       
   360     {
       
   361     __ASSERT_ALWAYS( iRtpmanager, User::Leave( KErrArgument ) );
       
   362     __ASSERT_ALWAYS( iDatapath, User::Leave( KErrArgument ) );
       
   363     
       
   364     TBool controlNetworkResources = SetStateL( EStateStreaming, aEndpointId );
       
   365     
       
   366     if ( !LocalStream() )
       
   367         {  
       
   368         if ( controlNetworkResources )
       
   369             {
       
   370             iRtpmanager->StartSessionL();
       
   371             }
       
   372             
       
   373         User::LeaveIfError( iRtpmanager->SetRTCPSendReceive( aEnableRtcp ) );
       
   374         }
       
   375     
       
   376     UpdateCodecLoadingPermission( ETrue );
       
   377     
       
   378     LoadCodecL( iCodecInfo, KNullDesC8 );
       
   379     
       
   380     DoPlayL();
       
   381     
       
   382     InformStreamStateChange( KMccStreamStarted, aEndpointId );
       
   383     }
       
   384 
       
   385 // -----------------------------------------------------------------------------
       
   386 // CMccSymSimpleDlStream::PauseL
       
   387 // Pauses audio streaming
       
   388 // -----------------------------------------------------------------------------
       
   389 //
       
   390 void CMccSymSimpleDlStream::PauseL( const TUint32 aEndpointId, TBool aEnableRtcp )
       
   391     {
       
   392     __ASSERT_ALWAYS( iRtpmanager, User::Leave( KErrArgument ) );
       
   393     __ASSERT_ALWAYS( iDatapath, User::Leave( KErrArgument ) );
       
   394     
       
   395     SetStateL( EStatePaused, aEndpointId );
       
   396     
       
   397      if ( !LocalStream() )
       
   398         { 
       
   399         User::LeaveIfError( iRtpmanager->SetRTCPSendReceive( aEnableRtcp ) );
       
   400         }
       
   401 
       
   402     DoPauseL();
       
   403     
       
   404     InformStreamStateChange( KMccStreamPaused, aEndpointId );
       
   405     }
       
   406 
       
   407 // -----------------------------------------------------------------------------
       
   408 // CMccSymSimpleDlStream::ResumeL
       
   409 // Resumes paused audio streaming
       
   410 // -----------------------------------------------------------------------------
       
   411 //
       
   412 void CMccSymSimpleDlStream::ResumeL( const TUint32 aEndpointId, TBool aEnableRtcp )
       
   413     {
       
   414     __ASSERT_ALWAYS( iRtpmanager, User::Leave( KErrArgument ) );
       
   415     __ASSERT_ALWAYS( iDatapath, User::Leave( KErrArgument ) );
       
   416     
       
   417     SetStateL( EStateStreaming, aEndpointId );
       
   418     
       
   419     if ( !LocalStream() )
       
   420         { 
       
   421         User::LeaveIfError( iRtpmanager->SetRTCPSendReceive( aEnableRtcp ) );
       
   422         }
       
   423 
       
   424     DoResumeL();
       
   425     
       
   426     InformStreamStateChange( KMccStreamResumed, aEndpointId );
       
   427     }
       
   428 
       
   429 // -----------------------------------------------------------------------------
       
   430 // CMccSymSimpleDlStream::StopL
       
   431 // Stops the audio streaming
       
   432 // -----------------------------------------------------------------------------
       
   433 //
       
   434 void CMccSymSimpleDlStream::StopL( const TUint32 aEndpointId )
       
   435     {
       
   436     __ASSERT_ALWAYS( iDatapath, User::Leave( KErrArgument ) );    
       
   437     
       
   438     SetStateL( EStateStopped, aEndpointId );
       
   439     
       
   440     DoStopL();
       
   441     
       
   442     InformStreamStateChange( KMccStreamStopped, aEndpointId );   
       
   443     }
       
   444     
       
   445 // -----------------------------------------------------------------------------
       
   446 // CMccSymSimpleDlStream::SetBalanceL
       
   447 // Sets the current play balance
       
   448 // -----------------------------------------------------------------------------
       
   449 //
       
   450 void CMccSymSimpleDlStream::SetBalanceL( TInt aLeftBal, TInt aRightBal )
       
   451     {
       
   452     if( !iSoundDevice )
       
   453         {
       
   454         User::Leave( KErrNotReady );
       
   455         }
       
   456     else
       
   457         {
       
   458         iSoundDevice->SetPlayBalanceL( aLeftBal, aRightBal );
       
   459         }
       
   460     }
       
   461 
       
   462 // -----------------------------------------------------------------------------
       
   463 // CMccSymSimpleDlStream::GetBalanceL
       
   464 // Returns the current play balance
       
   465 // -----------------------------------------------------------------------------
       
   466 //
       
   467 void CMccSymSimpleDlStream::GetBalanceL( TInt& aLeftbal, TInt& aRightbal )
       
   468     {
       
   469     if( !iSoundDevice )
       
   470         {
       
   471         User::Leave( KErrNotReady );
       
   472         }
       
   473     else
       
   474         {
       
   475         iSoundDevice->GetPlayBalanceL( aLeftbal, aRightbal );
       
   476         }
       
   477     }
       
   478     
       
   479 // -----------------------------------------------------------------------------
       
   480 // CMccSymSimpleDlStream::GetSSRCL
       
   481 // Returns SSRC value
       
   482 // -----------------------------------------------------------------------------
       
   483 //
       
   484 void CMccSymSimpleDlStream::GetSSRCL( TUint32& /*aSSRCValue*/ )
       
   485     {
       
   486     User::Leave ( KErrNotSupported );
       
   487     }
       
   488 
       
   489 
       
   490 // -----------------------------------------------------------------------------
       
   491 // CMccSymSimpleDlStream::ResetCountersL
       
   492 // Resets Jitterbuffer
       
   493 // -----------------------------------------------------------------------------
       
   494 //
       
   495 void CMccSymSimpleDlStream::ResetCountersL( )
       
   496     {
       
   497     }
       
   498 
       
   499 // -----------------------------------------------------------------------------
       
   500 // CMccSymSimpleDlStream::SendMediaSignalL
       
   501 // Downlink can send RTCP media signals (only receiver reports)
       
   502 // -----------------------------------------------------------------------------
       
   503 //
       
   504 void CMccSymSimpleDlStream::SendMediaSignalL( const TMccEvent& aEvent )
       
   505     {
       
   506     __ASSERT_ALWAYS( !LocalStream(), User::Leave( KErrArgument ) );
       
   507     __ASSERT_ALWAYS( iDatasource, User::Leave( KErrNotReady ) );
       
   508     
       
   509     CMccRtpDataSource* p = static_cast<CMccRtpDataSource*>( iDatasource );
       
   510     p->SendMediaSignallingL( aEvent );
       
   511     }
       
   512         
       
   513 // -----------------------------------------------------------------------------
       
   514 // CMccSymSimpleDlStream::SendRTCPReceiverReportL
       
   515 // Sends a RTCP receiver report
       
   516 // -----------------------------------------------------------------------------
       
   517 //  
       
   518 void CMccSymSimpleDlStream::SendRTCPReceiverReportL()
       
   519     {
       
   520     __ASSERT_ALWAYS( !LocalStream(), User::Leave( KErrArgument ) );
       
   521     __ASSERT_ALWAYS( iDatasource, User::Leave( KErrArgument ) );
       
   522 
       
   523     CMccRtpDataSource* dSource = static_cast<CMccRtpDataSource*>( iDatasource );
       
   524     User::LeaveIfError( dSource->SendRTCPReceiverReport() );
       
   525     }
       
   526 
       
   527 // -----------------------------------------------------------------------------
       
   528 // CMccSymSimpleDlStream::StartInactivityTimerL
       
   529 // Starts inactivity timer for a stream
       
   530 // -----------------------------------------------------------------------------
       
   531 // 
       
   532 void CMccSymSimpleDlStream::StartInactivityTimerL( TUint32 aTimeoutTime )
       
   533     {
       
   534     __ASSERT_ALWAYS( !LocalStream(), User::Leave( KErrArgument ) );
       
   535     __ASSERT_ALWAYS( iDatasource, User::Leave( KErrArgument ) );
       
   536     
       
   537     CMccRtpDataSource* dSource = static_cast<CMccRtpDataSource*>( iDatasource );
       
   538     dSource->StartInactivityTimerL( aTimeoutTime );
       
   539     }
       
   540 
       
   541       
       
   542 // -----------------------------------------------------------------------------
       
   543 // CMccSymSimpleDlStream::StopInactivityTimerL
       
   544 // Stops inactivity timer for a stream 
       
   545 // -----------------------------------------------------------------------------
       
   546 // 
       
   547 void CMccSymSimpleDlStream::StopInactivityTimerL()
       
   548     {
       
   549     __ASSERT_ALWAYS( !LocalStream(), User::Leave( KErrArgument ) );
       
   550     __ASSERT_ALWAYS( iDatasource, User::Leave( KErrArgument ) );
       
   551     
       
   552     CMccRtpDataSource* dSource = static_cast<CMccRtpDataSource*>( iDatasource );
       
   553     dSource->StopInactivityTimerL( );
       
   554     }
       
   555 
       
   556 // -----------------------------------------------------------------------------
       
   557 // CMccSymSimpleDlStream::IsUplink
       
   558 // -----------------------------------------------------------------------------
       
   559 // 
       
   560 TBool CMccSymSimpleDlStream::IsUplink()
       
   561     {
       
   562     return EFalse;
       
   563     }
       
   564 
       
   565 // -----------------------------------------------------------------------------
       
   566 // CMccSymSimpleDlStream::StandByL
       
   567 // -----------------------------------------------------------------------------
       
   568 // 
       
   569 void CMccSymSimpleDlStream::StandByL()
       
   570     {
       
   571     __ASSERT_ALWAYS( !LocalStream(), User::Leave( KErrArgument ) );
       
   572     __ASSERT_ALWAYS( iDatasource, User::Leave( KErrArgument ) );
       
   573     
       
   574     CMccRtpDataSource* dSource = static_cast<CMccRtpDataSource*>( iDatasource );
       
   575     dSource->StandBy( EForceStandby, iCodecInfo.iPayloadType );
       
   576     }
       
   577 
       
   578 // -----------------------------------------------------------------------------
       
   579 // CMccSymSimpleDlStream::JitterBufferError
       
   580 // -----------------------------------------------------------------------------
       
   581 // 
       
   582 void CMccSymSimpleDlStream::JitterBufferError( TInt /*aError*/ )
       
   583 	{
       
   584     }
       
   585 
       
   586 // -----------------------------------------------------------------------------
       
   587 // CMccSymDlStream::DynamicBufferChangeRequest
       
   588 // -----------------------------------------------------------------------------
       
   589 //
       
   590 void CMccSymSimpleDlStream::DynamicBufferChangeRequest( TInt /* aBufferSize*/ )
       
   591     {
       
   592     
       
   593     }
       
   594     
       
   595 // -----------------------------------------------------------------------------
       
   596 // CMccSymSimpleDlStream::MultiplexerSink
       
   597 // -----------------------------------------------------------------------------
       
   598 //
       
   599 MDataSink* CMccSymSimpleDlStream::MultiplexerSink()
       
   600     {
       
   601     return iFormatDecode;
       
   602     }
       
   603 
       
   604 // ========================== OTHER EXPORTED FUNCTIONS =========================
       
   605 
       
   606 //  End of File