1 /*

     2 * Copyright (c) 2007 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 the License "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:    RTSP Client impl.*

    15 */

    16 

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include "CCRRtspPacketSource.h"

    22 #include "CCRPunchPacketSender.h"

    23 #include "CCRRtpTcpStreamer.h"

    24 #include "CCRRtspCommand.h"

    25 #include "CCRPacketBuffer.h"

    26 #include <ipvideo/CDvrSdpParser.h>

    27 #include "CCRTimer.h"

    28 #include <Uri16.h>

    29 #include <e32msgqueue.h>

    30 #include <centralrepository.h>

    31 #include <WebUtilsInternalCRKeys.h>

    32 #include <mmf/common/mmferrors.h>  // ROP error codes

    33 

    34 // DATA TYPES

    35 // ######################################################

    36 // WARNING: JUMBOJET-SIZED KLUDGE AHEAD:

    37 // ######################################################

    38 #define private public

    39 // Explanation: timestamp getter in rtcp sender report

    40 // class is broken beyond repair. It may be fixed but the

    41 // broken version is already shipped to millions of phones

    42 // around the world. The broken getter method can't

    43 // be overridden as it requires access to private part

    44 // of sender reports instance variables. The item we

    45 // need (ntp timestamp) is there intact in private instance

    46 // variables but there is useless getter for that.

    47 #include <rtcp.h>

    48 

    49 /* sender report (SR) */

    50 class TRtcpSRPart

    51     {

    52 public:

    53     TUint32 ssrc;     /**< sender generating this report */

    54     TUint32 ntp_sec;  /**< NTP timestamp */

    55     TUint32 ntp_frac; /**< Fractal seconds */

    56     TUint32 rtp_ts;   /**< RTP timestamp */

    57     TUint32 psent;    /**< packets sent */

    58     TUint32 osent;    /**< octets sent */

    59     };

    60 #undef private

    61 // ######################################################

    62 // Major kludge ends here.

    63 // ######################################################

    64 

    65 // CONSTANTS

    66 const TInt KCRPortNumberBase( 16670 );

    67 const TInt KCSeqForRtspNegoation( 42 );

    68 const TInt KRtspPortNumber( 554 );

    69 const TInt KRtpPacketVersion( 2 ); 

    70 const TUint KSenderReportPacketType( 0xC8 ); // 200 decimal

    71 const TInt KDVR10Seconds( 10000000 );

    72 

    73 // The number of sequential packets that must be received

    74 // before a stream is considered good. 1 means no delay, start

    75 // from very first packet

    76 const TInt KDVRMinSequential( 1 ); 

    77 // The maximum number of dropped packets to be considered a

    78 // dropout, as opposed to an ended and restarted stream.    

    79 const TInt KDVRMaxMisorder( 50 ); 

    80 // The maximum number of packets by which a packet can be delayed 

    81 // before it is considered dropped. 

    82 const TInt KDVRMaxDropOut( 3000 ); 

    83 _LIT( KRtspPortString, "554" );

    84 _LIT8( KCRCName, "N++ " );

    85 // Timeout for RTP/UDP reception before switching to TCP mode

    86 const TTimeIntervalMicroSeconds32 KCRRtspRtpUdpTimeout( 10 * 1e6 );

    87 // Timeout for waiting for server response to any RTSP command

    88 const TTimeIntervalMicroSeconds32 KCRRtspResponseTimeout( 15 * 1e6 );

    89 // Timeout for waiting for server response to TIERDOWN command

    90 const TTimeIntervalMicroSeconds32 KCRRtspTierdownTimeout( 3 * 1e6 );

    91 

    92 // ============================ MEMBER FUNCTIONS ===============================

    93 

    94 // -----------------------------------------------------------------------------

    95 // CCRRtspPacketSource::NewL

    96 // Two-phased constructor.

    97 // -----------------------------------------------------------------------------

    98 //

    99 CCRRtspPacketSource* CCRRtspPacketSource::NewL(

   100     const SCRRtspParams& aParams,

   101     CCRConnection& aConnection,

   102     RSocketServ& aSockServer,

   103     MCRStreamObserver& aSessionObs,

   104     CCRStreamingSession& aOwningSession )

   105     {

   106     CCRRtspPacketSource* self = new( ELeave )

   107         CCRRtspPacketSource( aConnection, aSockServer, aSessionObs, aOwningSession );

   108     CleanupStack::PushL( self );

   109     self->ConstructL( aParams );

   110     CleanupStack::Pop( self );

   111     return self;

   112     }

   113 

   114 // -----------------------------------------------------------------------------

   115 // CCRRtspPacketSource::CCRRtspPacketSource

   116 // C++ default constructor can NOT contain any code, that might leave.

   117 // -----------------------------------------------------------------------------

   118 //

   119 CCRRtspPacketSource::CCRRtspPacketSource(

   120     CCRConnection& aConnection,

   121     RSocketServ& aSockServer,

   122     MCRStreamObserver& aSessionObs,

   123     CCRStreamingSession& aOwningSession )

   124   : CCRPacketSourceBase( aOwningSession, CCRStreamingSession::ECRRtspSourceId ),

   125     iSockServer( aSockServer ),

   126     iConnection( aConnection ),

   127     iStage( ERTSPInit ),

   128     iCSeq( KCSeqForRtspNegoation ),

   129     iClientPort( KCRPortNumberBase ),

   130     iSessionId(NULL, 0 ),

   131     iReadyToPlay(EFalse),

   132     iSessionObs( aSessionObs ),

   133     iStartPos( KRealZero ),

   134     iEndPos( KRealMinusOne ),

   135     iUdpFound( EFalse ),

   136     iTrafficFound( EFalse )

   137     {

   138     // None

   139     }

   140 

   141 // -----------------------------------------------------------------------------

   142 // CCRRtspPacketSource::ConstructL

   143 // Symbian 2nd phase constructor can leave.

   144 // -----------------------------------------------------------------------------

   145 //

   146 void CCRRtspPacketSource::ConstructL( const SCRRtspParams& aParams )

   147     {

   148     LOG( "CCRRtspPacketSource::ConstructL() in" );

   149     if ( aParams.iUrl.Length() == 0 ) 

   150         {

   151         User::Leave ( KErrArgument ); 

   152         }

   153 

   154     iSentData = HBufC8::NewL ( KCROptionsReply().Length() + KMaxInfoName );

   155     iRtpTcpStreamer = CCRRtpTcpStreamer::NewL( *this );

   156     iRtspUri = aParams.iUrl.AllocL();

   157     iRtspUri8 = HBufC8::NewL( aParams.iUrl.Length());

   158     iRtspUri8->Des().Copy( aParams.iUrl );

   159     iUserName = aParams.iUserName.AllocL();

   160     iPassword = aParams.iPassword.AllocL();

   161     User::LeaveIfError( iConnection.RegisterObserver( this ) );

   162     iUdpReceptionTimer = CCRTimer::NewL( EPriorityLow, *this );

   163     iProxyServerAddr = aParams.iProxyServerAddr; 

   164     iProxyServerPort = aParams.iProxyServerPort; 

   165     DoConnectL(); // Makes no sense to construct without immediately connecting

   166 

   167     LOG( "CCRRtspPacketSource::ConstructL() out" );

   168     }

   169 

   170 // -----------------------------------------------------------------------------

   171 // CCRRtspPacketSource::~CCRRtspPacketSource

   172 // Destructor.

   173 // -----------------------------------------------------------------------------

   174 //

   175 CCRRtspPacketSource::~CCRRtspPacketSource()

   176     {

   177     LOG( "CCRRtspPacketSource::~CCRRtspPacketSource() in" );

   178     // Deletes everything related to session

   179     CleanUp();

   180     delete iRtspTimeout;

   181     delete iSentData;

   182     delete iAuthType;

   183     delete iRtspUri8;

   184     delete iUserName;

   185     delete iPassword;

   186     delete iNonce;

   187     delete iOpaque;

   188     delete iRealm;

   189     delete iRtpTcpStreamer;

   190     delete iUdpReceptionTimer;

   191     iReceiveStreams.Reset();

   192     iObserver = NULL;

   193     iConnection.UnregisterObserver( this );

   194     LOG( "CCRRtspPacketSource::~CCRRtspPacketSource() out" );

   195     }

   196 

   197 // -----------------------------------------------------------------------------

   198 // CCRRtspPacketSource::CleanUp

   199 // Callback method called from cleanup-cidle that just calls the actual

   200 // cleanup method.

   201 // -----------------------------------------------------------------------------

   202 //

   203 void CCRRtspPacketSource::CleanUp()

   204     {

   205     LOG( "CCRRtspPacketSource::CleanUp() in" );

   206     if ( iUdpReceptionTimer )

   207         {

   208         iUdpReceptionTimer->Cancel();

   209         }

   210     delete iRtspPingTimer;

   211     iRtspPingTimer = NULL;

   212 

   213     iRtpRecvSrcAudio.Close();

   214     iRtpRecvSrcVideo.Close();

   215     iAudioSession.Close();

   216     iVideoSession.Close();

   217     iReadyToPlay = EFalse;

   218     delete iSdpParser; iSdpParser = NULL;

   219     delete iRtspUri; iRtspUri = NULL;

   220     delete iRtspSock; iRtspSock = NULL;

   221 

   222     for ( TInt i( 0 ); i < ERTPMaxSockets; i++ )

   223         {

   224         delete iRTPSockArr[i];

   225         iRTPSockArr[i] = NULL;

   226         }

   227     for ( TInt i( 0 ); i < ERTSPLastStage; i++ )

   228         {

   229         delete iPrevCommands[i];

   230         iPrevCommands[i] = NULL;

   231         delete iResponses[i];

   232         iResponses[i] = NULL;

   233         }

   234     

   235     iSessionId.Set( NULL, 0 );

   236     delete iPunchPacketSenderAudio; iPunchPacketSenderAudio = NULL;

   237     delete iPunchPacketSenderVideo; iPunchPacketSenderVideo = NULL;

   238     delete iUserAgent; iUserAgent = NULL;

   239     delete iWapProfile; iWapProfile = NULL;

   240     iStartPos = KRealZero;

   241     iEndPos = KRealMinusOne;

   242     

   243     LOG( "CCRRtspPacketSource::CleanUp() out" );

   244     }

   245 

   246 // -----------------------------------------------------------------------------

   247 // CCRRtspPacketSource::DoConnectL

   248 // -----------------------------------------------------------------------------

   249 //

   250 void CCRRtspPacketSource::DoConnectL( void )

   251     {

   252     if ( !iRtspUri )

   253         {

   254         User::Leave( KErrNotReady );

   255         }

   256     if ( iRtspSock )

   257         {

   258         delete iRtspSock; iRtspSock = NULL;

   259         }

   260 

   261     iRtspSock = CCRSock::NewL( *this, ERTPControl, iConnection.Connection(),

   262                                iSockServer, ETrue, ETrue );

   263     TUriParser uriParser;

   264     User::LeaveIfError( uriParser.Parse( iRtspUri->Des() ) );

   265     iRtspUriHost.Set( uriParser.Extract( EUriHost ) );

   266     TPtrC portString( KRtspPortString );

   267     if ( uriParser.IsPresent( EUriPort ) )

   268         {

   269         portString.Set( uriParser.Extract( EUriPort ) );

   270         }

   271     

   272     TLex portLex( portString );

   273     TInt port( KRtspPortNumber );

   274     if ( portLex.Val( port ) != KErrNone )

   275         {

   276         User::Leave( KErrMMInvalidURL );

   277         }

   278     if ( iProxyServerAddr.Length() && iProxyServerPort )

   279         {

   280         LOG2( "CCRRtspPacketSource::DoConnectL(), Proxy: %S port: %d",

   281             &iProxyServerAddr, iProxyServerPort );

   282         User::LeaveIfError( iRtspSock->ConnectSock( iProxyServerAddr, iProxyServerPort ) );      

   283         }

   284     else

   285         {

   286         User::LeaveIfError(iRtspSock->ConnectSock( iRtspUriHost, port ) );

   287         }

   288     iCSeq = KCSeqForRtspNegoation;

   289 

   290     TTime now;

   291     now.UniversalTime();

   292     iClientPort = 

   293         KCRPortNumberBase + ( ( now.DateTime().MicroSecond() / 1000 ) * 2 );

   294 

   295     // Get transport method from connection heuristics

   296     iTransport = ( iConnection.GetHeuristic(

   297         CCRConnection::EUdpStreamingBlocked ) )? ERTPOverTCP: ERTPOverUDP;

   298     LOG1( "CCRRtspPacketSource::DoConnectL(), RTP transport: %d (0=UDP, 1=TCP)", iTransport );

   299 

   300     // Get user agent, bandwidth and wap profile based on connection bearer (3G or not)

   301     TConnMonBearerType bearer = iConnection.BearerType();

   302     TBool is3g( iConnection.IsBearerWLANor3G( bearer ) );

   303 

   304     // Fetch wap profile from WebUtils repository

   305     if ( !iWapProfile )

   306         {

   307         CRepository* repository = CRepository::NewLC( KCRUidWebUtils );

   308         TUint32 profilekey = ( is3g )? KWebUtilsUaProf3G: KWebUtilsUaProf;

   309         TFileName profilebuf( KNullDesC );

   310         if ( !repository->Get( profilekey, profilebuf ) )

   311             {

   312             iWapProfile = HBufC8::NewL( profilebuf.Length() );

   313             iWapProfile->Des().Copy( profilebuf );

   314             }

   315         

   316         CleanupStack::PopAndDestroy( repository );

   317         LOG1( "CCRRtspPacketSource::DoConnectL(), iWapProfile: %S", &profilebuf );

   318         }

   319 

   320     // Fetch user agent

   321     // Should we add version information to user agent string?

   322     delete iUserAgent; iUserAgent = NULL;

   323     iUserAgent = KCRRTSPDefaultUserAgent().AllocL();

   324 

   325     // Get bandwidth from connection

   326     iBandwidth = iConnection.MaximumBandwidth();

   327 

   328     LOG( "CCRRtspPacketSource::DoConnectL out" );

   329     }

   330 

   331 // -----------------------------------------------------------------------------

   332 // CCRRtspPacketSource::URI

   333 // -----------------------------------------------------------------------------

   334 //

   335 TPtr CCRRtspPacketSource::URI(void)

   336     {

   337     __ASSERT_DEBUG( iRtspUri != NULL , User::Panic( _L( "RTSP source" ), KErrBadHandle ) );

   338     TPtr retval ( NULL , 0 );

   339     if ( iRtspUri ) 

   340         {

   341         retval.Set( iRtspUri->Des() );

   342         }

   343     else

   344         {

   345         LOG( "CCRRtspPacketSource::URI iRtspUri was NULL !!!!!!!!!! " );

   346         }

   347     return retval; 

   348     }

   349 

   350 // -----------------------------------------------------------------------------

   351 // CCRRtspPacketSource::GetSdp

   352 // -----------------------------------------------------------------------------

   353 //

   354 TInt CCRRtspPacketSource::GetSdp( TPtrC8& aSdp )

   355     {

   356     TInt retval( KErrNotReady );

   357     if ( iSdpParser )

   358         {

   359         return iSdpParser->GetSdp( aSdp );

   360         }

   361     

   362     return retval;

   363     }

   364 

   365 // -----------------------------------------------------------------------------

   366 // CCRRtspPacketSource::SeqAndTS

   367 // -----------------------------------------------------------------------------

   368 //

   369 TInt CCRRtspPacketSource::SeqAndTS(

   370     TUint& aAudioSeq,

   371     TUint& aAudioTS,

   372     TUint& aVideoSeq,

   373     TUint& aVideoTS )

   374     {

   375     TInt retval( KErrNotReady );

   376     if ( iSeqFromRtpInfoForVideo != 0 || iSeqFromRtpInfoForAudio != 0  )

   377         {

   378         aAudioSeq = iSeqFromRtpInfoForAudio;

   379         aAudioTS = iRTPTimeStampAudio;

   380         aVideoSeq = iSeqFromRtpInfoForVideo;

   381         aVideoTS = iRTPTimeStampVideo;

   382         retval = KErrNone;

   383         }

   384     

   385     return retval;

   386     }

   387 

   388 // -----------------------------------------------------------------------------

   389 // CCRRtspPacketSource::PostActionL

   390 // -----------------------------------------------------------------------------

   391 //

   392 void CCRRtspPacketSource::PostActionL()

   393     {

   394     LOG1( "CCRRtspPacketSource::PostActionL(), SDP will be handled, iSdpParser: %d",

   395                                                                     iSdpParser );

   396     User::LeaveIfNull( iSdpParser );

   397     iSessionObs.StatusChanged( MCRPacketSource::ERtpStateSdpAvailable );

   398     }

   399 

   400 // -----------------------------------------------------------------------------

   401 // CCRRtspPacketSource::Play

   402 // -----------------------------------------------------------------------------

   403 //

   404 TInt CCRRtspPacketSource::Play( const TReal& aStartPos, const TReal& aEndPos )

   405     {

   406     LOG2( "CCRRtspPacketSource::Play(), aStartPos: %f, aEndPos: %f",

   407                                         aStartPos, aEndPos );

   408     LOG2( "CCRRtspPacketSource::Play(), sent seq: %d, rec: %d", 

   409                                         iCSeq, iLastReceivedSeq );

   410     iReadyToPlay = ETrue;

   411     iStartPos = aStartPos;

   412     iEndPos = aEndPos;

   413     ResetStreamFlags();

   414 

   415     // In xps case we never get startpos with this method. 

   416     // instead setposition will be called 

   417     if ( iBuffer )

   418         {

   419         iBuffer->ResetBuffer();

   420         }    

   421 

   422     // If both audio and video sessions are closed, we

   423     // need to open at least one of them:

   424     TInt err( KErrNone );

   425     if ( iStage == ERTSPReadyToPlay || iStage == ERTSPPauseSent )

   426         {

   427         if ( iStage == ERTSPReadyToPlay || iCSeq == ( iLastReceivedSeq + 1 ) )

   428             {

   429             TRAP( err, SendPlayCommandL() );

   430             }

   431         else

   432             { 

   433             // We have a fast-fingered user in charge; play has been issued

   434             // but the previous pause has not been completed yet: postpone this

   435             // operation

   436             iPostPonedPlay = ETrue;

   437             }

   438         }

   439     

   440     return err;

   441     }

   442 

   443 // -----------------------------------------------------------------------------

   444 // CCRRtspPacketSource::Pause

   445 // -----------------------------------------------------------------------------

   446 //

   447 TInt CCRRtspPacketSource::Pause()

   448     {

   449     LOG1( "CCRRTSPPacketSource::Pause() stage %d", iStage );

   450     TInt err( KErrNotReady );

   451     if ( iStage == ERTSPPlaying )

   452         {

   453         if ( iResponses[ERTSPPlaySent]->IsLiveStream() || iSdpParser->IsLiveStream() )

   454             {

   455             err = KErrNotSupported;

   456             }

   457         else

   458             {

   459             TRAP( err, SendPauseCommandL() );

   460             }

   461         }

   462     if ( iStage == ERTSPPauseSent )

   463         {

   464         err = KErrNone;

   465         }

   466     return err;

   467     }

   468 

   469 // -----------------------------------------------------------------------------

   470 // CCRRtspPacketSource::Stop

   471 // -----------------------------------------------------------------------------

   472 //

   473 TInt CCRRtspPacketSource::Stop()

   474     {

   475     LOG( "CCRRtspPacketSource::Stop()" );

   476     

   477     iReadyToPlay = EFalse;

   478     iPostPonedPlay = EFalse;

   479     iStartPos = KRealZero;

   480     TInt err( KErrDisconnected );

   481     

   482     if ( iStage == ERTSPPlaySent || iStage == ERTSPPlaying ||

   483          iStage == ERTSPPauseSent || iStage == ERTSPSetupAudioSent ||

   484          iStage == ERTSPSetupVideoSent )

   485         {

   486         err = KErrNone;

   487         if ( iRtspSock )

   488             {

   489             iRtspSock->Cancel();

   490             }

   491        

   492         TRAP_IGNORE( SendTearDownCommandL() ); // if this fails, we don't care

   493         iStage = ERTSPTearDownSent;

   494         StartRtspTimeout( KCRRtspTierdownTimeout );

   495         }

   496 

   497     return err;

   498     }

   499 

   500 // -----------------------------------------------------------------------------

   501 // CCRRtspPacketSource::SetPosition

   502 // -----------------------------------------------------------------------------

   503 

   504 TInt CCRRtspPacketSource::SetPosition( const TInt64 aPosition ) 

   505     {

   506     LOG1( "CCRRtspPacketSource::SetPosition(), iStartPos: %f", iStartPos );

   507 

   508     if ( aPosition == -2 )

   509         {

   510         if ( iStage != ERTSPPlaySent && iObserver )

   511             {

   512             iObserver->ConnectionStatusChange(

   513                 iOwningSession.SourceChecksum(),

   514                 ECRReadyToSeek, KErrNone );

   515             }

   516         }

   517     return KErrNone;

   518     }

   519 

   520 // -----------------------------------------------------------------------------

   521 // CCRRtspPacketSource::GetRange

   522 // -----------------------------------------------------------------------------

   523 void CCRRtspPacketSource::GetRange( TReal& aLower, TReal& aUpper )

   524     {

   525     aLower = KRealZero;

   526     aUpper = KRealMinusOne;

   527 

   528     if ( ( iStage == ERTSPPlaySent || iStage == ERTSPPlaying ) &&

   529          iResponses[ERTSPPlaySent] )

   530          {

   531          iResponses[ERTSPPlaySent]->GetRange(aLower,aUpper);

   532          }

   533     }

   534 

   535 // -----------------------------------------------------------------------------

   536 // CCRRtspPacketSource::DataReceived

   537 // This is called when data is received from socket.

   538 // -----------------------------------------------------------------------------

   539 //

   540 void CCRRtspPacketSource::DataReceived( TInt /*aSockId*/, const TDesC8& aData )

   541     {

   542     // Find out RTCP message or RTP packet from IP packet

   543     iRtpTcpStreamer->DataAvailable( aData, ( iTransport == ERTPOverTCP ) );

   544     }

   545     

   546 // -----------------------------------------------------------------------------

   547 // CCRRtspPacketSource::RtspMsgAvailable

   548 // This is called when data is received from socket.

   549 // -----------------------------------------------------------------------------

   550 //

   551 void CCRRtspPacketSource::RtspMsgAvailable( const TDesC8& aData )

   552     {

   553 #if defined ( LIVE_TV_FILE_TRACE ) || defined ( LIVE_TV_RDEBUG_TRACE )

   554     if ( aData.Length() > 0 )

   555         {

   556         LOG1( "CCRRtspPacketSource::RtspMsgAvailable(), aData len: %d", aData.Length() );

   557         TName d( KNullDesC );

   558         for( TInt i( 0 );  i < aData.Length(); i++ )

   559             {

   560             TChar c = aData[i];

   561             d.Append( c );

   562             if ( ( i > 0 ) && ( i % 80 ) == 0 )

   563                 {

   564                 LOG1( ">%S<", &d );

   565                 d.Zero();

   566                 }

   567             }

   568         

   569         LOG1( ">%S<", &d );

   570         }

   571 #endif // LIVE_TV_FILE_TRACE || LIVE_TV_RDEBUG_TRACE

   572 

   573     TRAPD( err, ProcessRtspResponseL( aData ) );

   574     if ( err )

   575         {

   576         LOG1( "CCRRtspPacketSource::RtspMsgAvailable(), ProcessRtspResponseL Leaved, err: %d", err );

   577         if ( err == KErrNotSupported ) 

   578             {

   579             // The response did not look like rtsp response at all. 

   580             // some servers decide to send rtsp commands to us so lets

   581             // try interpreting it as a command

   582             err = KErrNone; 

   583             TRAP( err, ProcessRTSPCommandL( aData ) )

   584             if ( err )

   585                 {

   586                 iOwningSession.SourceStop();                

   587                 }

   588             }

   589         else

   590             {

   591             iOwningSession.SourceStop();

   592             }

   593         }

   594     }

   595 

   596 // -----------------------------------------------------------------------------

   597 // CCRRtspPacketSource::SockStatusChange

   598 // This is called when socket status changes.

   599 // -----------------------------------------------------------------------------

   600 //

   601 void CCRRtspPacketSource::SockStatusChange(

   602     TInt aSockId, 

   603     CCRSock::TCRSockStatus aStatus,

   604     TInt aError )

   605     {

   606 #if defined ( LIVE_TV_FILE_TRACE ) || defined ( LIVE_TV_RDEBUG_TRACE )

   607     if ( aStatus == CCRSock::EFailed )

   608         {

   609         LOG3( "CCRRtspPacketSource::SockStatusChange(), aSockId: %d,  aStatus: %d, aError: %d",

   610                                                         aSockId, aStatus, aError );

   611         }

   612 #else // LIVE_TV_FILE_TRACE || LIVE_TV_RDEBUG_TRACE

   613     ( void )aSockId;

   614     ( void )aError;

   615 #endif // LIVE_TV_FILE_TRACE || LIVE_TV_RDEBUG_TRACE

   616 

   617     if ( aStatus == CCRSock::EFailed )

   618         {

   619         // Ask session to perform cleanup

   620         iOwningSession.SourceStop();

   621 

   622         if ( iStage == ERTSPInit && aSockId == ERTPControl && aError == KErrCouldNotConnect )

   623             {

   624             // map error to different error id, so we can know that showing reconnect query is pointless.

   625             aError = KErrEof;

   626             }

   627         

   628         // Inform the observer that there is a problem. Exclude case where we're closing

   629         // and the error is KErrEof

   630         if ( ! ( iStage == ERTSPTearDownSent && aError == KErrEof ) ) 

   631             {

   632             if ( iObserver )

   633                 {

   634                 iObserver->ConnectionStatusChange(

   635                     iOwningSession.SourceChecksum(), ECRConnectionError, aError );

   636                 }

   637             }

   638         else

   639             {

   640             LOG( "CCRRtspPacketSource::SockStatusChange(), eof in closing: normal" );

   641             }

   642         }

   643     else if ( aSockId == ERTPControl && aStatus == CCRSock::EIdle && 

   644               iStage == ERTSPInit )

   645         {

   646         // Called once from here for lifetime of this object

   647         TRAPD( err, SendRtspCommandL() ); 

   648         if ( err )

   649             {

   650             LOG1( "CCRRtspPacketSource::SockStatusChange(), SendRtspCommandL Leaved: %d", err );

   651     

   652             // Ask session to perform cleanup

   653             iOwningSession.SourceStop();

   654             }

   655         }

   656     }

   657 

   658 // -----------------------------------------------------------------------------

   659 // CCRRtspPacketSource::RtpTcpPacketAvailable

   660 // -----------------------------------------------------------------------------

   661 //

   662 void CCRRtspPacketSource::RtpTcpPacketAvailable(

   663     TInt aChannel,

   664     const TDesC8& aPacket )

   665     {

   666     // Map embedded TCP channel to streamid:

   667     // video: channel=(0,1) --> id=(2,3)

   668     // audio: channel=(2,3) --> id=(0,1)  when video present

   669     // audio: channel=(0,1) --> id=(0,1)  when audio only

   670     TInt mappedChannel( ( iSdpParser->VideoControlAddr().Length() )? 

   671                         ( aChannel + 2 ) % 4: aChannel );

   672     MCRPacketSource::TCRPacketStreamId streamid( 

   673         ( MCRPacketSource::TCRPacketStreamId )( mappedChannel ) );

   674 

   675     iBuffer->AddPacket( streamid, aPacket );

   676     }

   677 

   678 // -----------------------------------------------------------------------------

   679 // CCRRtspPacketSource::ForwardRtpTcpChunk

   680 // -----------------------------------------------------------------------------

   681 //

   682 void CCRRtspPacketSource::ForwardRtpTcpChunck( const TDesC8& aChunk )

   683     {

   684     if ( iRtspSock )

   685         {

   686         iRtspSock->SendData( aChunk );

   687         }

   688     }

   689 

   690 // -----------------------------------------------------------------------------

   691 // CCRRtspPacketSource::TimerExpired

   692 // -----------------------------------------------------------------------------

   693 //

   694 void CCRRtspPacketSource::TimerExpired( CCRTimer* )

   695     {

   696     LOG( "CCRRtspPacketSource::TimerExpired: RTP/UDP timer expired, switching to RTP/TCP" );

   697 

   698     if ( !iUdpFound )

   699         {            

   700         // Signal heuristic for TCP streaming

   701         LOG( "CCRRtspPacketSource::TimerExpired - Switch to TCP" );

   702         iConnection.SetHeuristic( CCRConnection::EUdpStreamingBlocked, ETrue );

   703         }

   704     else

   705         {

   706         // We had UDP before in this session but now it is lost for some reason.

   707         // Try UDP again.

   708         

   709         // Flag UDP found away

   710         iUdpFound = EFalse;

   711         iTrafficFound = EFalse;

   712         

   713         // Clear stream followup

   714         iReceiveStreams.Reset();

   715         

   716         LOG( "CCRRtspPacketSource::TimerExpired - Trying UDP again" );

   717         }

   718     

   719     // Notify client to close us and start a new session

   720     if ( iObserver )

   721         {

   722         // Notify client

   723         iObserver->ConnectionStatusChange(

   724             iOwningSession.SourceChecksum(), ECRSwitchingToTcp, KErrNone );

   725         }

   726     else

   727         {

   728         // If no client observer, teardown and cleanup ourselves

   729         iPostPonedPlay = EFalse; 

   730         TRAPD( err, SendTearDownCommandL() );

   731         if ( err != KErrNone )

   732             {

   733             LOG1( "CCRRtspPacketSource::TimerExpired() Send TEARDOWN failed: %d", err );

   734             }

   735     

   736         CleanUp();

   737         iSessionObs.StatusChanged( MCRPacketSource::ERtpStateClosing );

   738         }

   739     }

   740 

   741 // -----------------------------------------------------------------------------

   742 // CCRRtspPacketSource::ProcessRTSPCommandL

   743 // -----------------------------------------------------------------------------

   744 //

   745 void CCRRtspPacketSource::ProcessRTSPCommandL( const TDesC8& aData )

   746     {

   747     LOG1( "CCRRtspPacketSource::ProcessRTSPCommandL(), iStage: %d", ( int )iStage );

   748 

   749     CCRRtspCommand* cmd = CCRRtspCommand::NewL();

   750     CleanupStack::PushL( cmd );

   751     cmd->TryParseL( aData );

   752     

   753     switch ( cmd->Command() )

   754         {

   755         case CCRRtspCommand::ERTSPCommandOPTIONS:

   756             iSentData->Des().Format( KCROptionsReply, cmd->CSeq() );

   757             iRtspSock->SendData( iSentData->Des() );

   758             break;

   759             

   760         default:

   761             // Server sent us a command and it is not options. 

   762             // for sure they want us to stop ; is there 

   763             iOwningSession.SourceStop();

   764             break;

   765         }

   766     

   767     CleanupStack::PopAndDestroy( cmd );

   768     }

   769 

   770 // -----------------------------------------------------------------------------

   771 // CCRRtspPacketSource::ProcessRtspResponseL

   772 // -----------------------------------------------------------------------------

   773 //

   774 void CCRRtspPacketSource::ProcessRtspResponseL( const TDesC8& aData )

   775     {

   776     LOG1( "CCRRtspPacketSource::ProcessRtspResponseL(), iStage: %d", iStage );

   777 

   778     // Cancel timeout timer

   779     if ( iRtspTimeout )

   780         {

   781         iRtspTimeout->Cancel();

   782         }

   783 

   784     // The server responded to our TEARDOWN command. No need to parse the response

   785     // since we don't care what the server said. Ask session to clean us up.

   786     if ( iStage == ERTSPTearDownSent )

   787         {

   788         iOwningSession.SourceStop();

   789         return;

   790         }

   791 

   792     // First parse response

   793     CCRRtspResponse* resp = CCRRtspResponse::NewL();

   794     CleanupStack::PushL( resp );

   795     resp->TryParseL( aData );

   796     

   797     // Then find the command that this resp is associated with:

   798     iLastReceivedSeq = resp->CSeq(); 

   799     TBool commandFound( EFalse );

   800     for ( TInt i( 0 ); i < ERTSPLastStage && !commandFound; i++ )

   801         {

   802         LOG2( "CCRRtspPacketSource:: prevcommand stage: %d cseq: %d", 

   803             i, ( iPrevCommands[i] )? iPrevCommands[i]->CSeq(): KErrNotFound );

   804         

   805         if ( iPrevCommands[i] && ( iPrevCommands[i]->CSeq() == resp->CSeq() ) )

   806             {

   807             LOG1( "CCRRtspPacketSource::ProcessRtspResponseL(), matching command: %d", i );

   808             LOG1( "CCRRtspPacketSource::ProcessRtspResponseL(), cseq was: %d", resp->CSeq() );

   809             delete iResponses[i];

   810             CleanupStack::Pop( resp );

   811             iResponses[i] = resp;

   812             commandFound = ETrue;

   813             if ( i == ERTSPOptSent )

   814                 {

   815                 // Process options no further, used only for ping here

   816                 return; 

   817                 }

   818             }

   819         }

   820     

   821     // Delete response if sequency not match

   822     if ( !commandFound )

   823         {

   824         CleanupStack::PopAndDestroy( resp );

   825         LOG1( "CCRRtspPacketSource::ProcessRtspResponseL(), Command not found, cseq: %d", resp->CSeq() );

   826         }

   827     else

   828         {

   829         if ( iResponses[iStage]->StatusCode() ==  CCRRtspResponse::ERTSPRespOK ||      // 200

   830              iResponses[iStage]->StatusCode() ==  CCRRtspResponse::ERTSPRespCreated )  // 201

   831             {

   832             // Extract useful information from response depending on stage:

   833             switch ( iStage )

   834                 {

   835                 case ERTSPSetupAudioSent: // From setups take session id

   836                 case ERTSPSetupVideoSent:

   837                     if ( !iSessionId.Ptr() )

   838                         {

   839                         iResponses[iStage]->SessionId( iSessionId );

   840                         }

   841                     // Check for sdp parser and send punch packets for UDP transport

   842                     // (TCP or multicast: session setup and PLAY in SendRTSPCommand)

   843                     if ( iSdpParser && iTransport == ERTPOverUDP )

   844                         {

   845                         // If we see that we don't need to send further setups,

   846                         // do send punch packets now.

   847                         if ( ( iSdpParser->VideoControlAddr().Length() && // if we have video

   848                              iResponses[ERTSPSetupVideoSent] &&   // and we have video se tup

   849                              iSdpParser->AudioControlAddr().Length() &&   // and we have audio

   850                              iResponses[ERTSPSetupAudioSent] ) || // and we have audio set up or...

   851                            ( !iSdpParser->VideoControlAddr().Length() &&  // if we have no video

   852                              !iResponses[ERTSPSetupVideoSent] &&  // and we've video not set up

   853                              iSdpParser->AudioControlAddr().Length() &&   // and it shows we have audio

   854                              iResponses[ERTSPSetupAudioSent] ) || // and we've audio set up or...

   855                            ( iSdpParser->VideoControlAddr().Length() &&   // if we have video

   856                              iResponses[ERTSPSetupVideoSent] &&   // and we have video set up

   857                              !iSdpParser->AudioControlAddr().Length() &&  // and we have no audio

   858                              !iResponses[ERTSPSetupAudioSent] ) ) // and we have no audio set up

   859                             {

   860                             SendPunchPacketsL();

   861                             }

   862                         }

   863                     

   864                     // Notify sink that SETUP repply received

   865                     iSessionObs.StatusChanged(

   866                         MCRPacketSource::ERtpStateSetupRepply );

   867                     break;

   868                 

   869                 case ERTSPDescSent: // From desc take sdp

   870                     if ( iObserver && iResponses[iStage]->ContentLen() <= 0 )

   871                         { 

   872                         // This should not happen

   873                         if ( iObserver ) 

   874                             {

   875                             iObserver->ConnectionStatusChange(

   876                                 iOwningSession.SourceChecksum(), ECRConnectionError, KErrUnderflow );

   877                             }

   878                         iOwningSession.SourceStop();

   879                         }

   880                     else

   881                         {

   882                         delete iSdpParser; iSdpParser = NULL;

   883                         iSdpParser = CDvrSdpParser::NewL();

   884                         if ( iResponses[iStage]->ContentBase().Length() )

   885                             {

   886                             iSdpParser->TryParseL( iResponses[iStage]->Content(), 

   887                                                    iResponses[iStage]->ContentBase() );

   888                             }

   889                         else

   890                             {

   891                             iSdpParser->TryParseL( iResponses[iStage]->Content(), 

   892                                                    iRtspUri8->Des() );

   893                             }                  

   894                         // Check for multicast address in SDP

   895                         if ( iSdpParser->IsMultiCastSdp() )

   896                             {

   897                             iTransport = ERTPOverMulticast;

   898                             }

   899                         if ( iObserver && iSdpParser->IsRealMediaContent() )

   900                             {

   901                             iObserver->ConnectionStatusChange(

   902                                 iOwningSession.SourceChecksum(),

   903                                 ECRStreamIsRealMedia, KErrNotSupported );

   904                             iOwningSession.SourceStop();

   905                             return; // Make sure we don't continue with SETUP commands

   906                             }

   907                         else // do not send realmedia sdp to sinks

   908                             { 

   909                             if ( iObserver && iSdpParser->IsLiveStream() )

   910                                 {

   911                                 iObserver->ConnectionStatusChange(

   912                                     iOwningSession.SourceChecksum(),

   913                                     ECRStreamIsLiveStream, KErrNone );

   914                                 }

   915                             

   916                             // then check for bandwidth requirements even before we start:

   917                             if ( iObserver )

   918                                 {

   919                                 // Unknown bitrate or bandwidth are returned as zero.

   920                                 // Bitrates in kbit/s

   921                                 TInt bitrate( iSdpParser->VideoBitrate() + 

   922                                               iSdpParser->AudioBitrate() );

   923                                 TInt bandwidth( iConnection.MaximumBandwidth() / 1000 );

   924                                 if ( bitrate && bandwidth && bandwidth < bitrate )

   925                                     {

   926                                     LOG2( "CCRRtspPacketSource::ProcessRtspResponseL(), bitrate:%d, bandwidth: %d -> NotEnoughBandwidth",

   927                                                                                         bitrate, bandwidth);

   928                                     iObserver->ConnectionStatusChange(

   929                                         iOwningSession.SourceChecksum(),

   930                                         ECRNotEnoughBandwidth, KErrNone );

   931                                     return; // Make sure we don't tell sinks anything about

   932                                             // sdp that has too high bitrate for our network bearer

   933                                     }

   934                                 }

   935                             

   936                             // But if we didn't have realmedia stream and the bandwidth check

   937                             // is also all right, then go on and tell the sinks ->

   938                             iSessionObs.StatusChanged(

   939                                 MCRPacketSource::ERtpStateSdpAvailable );

   940                             }

   941                         }

   942                     break;

   943                 

   944                 case ERTSPPlaySent:

   945                     {

   946                     CCRRtspResponse::SRTPInfoHeader rtpInfo;

   947                     iResponses[ERTSPPlaySent]->RTPInfoHeader( rtpInfo );

   948 

   949                     TPtrC8 videoAddr ( NULL, 0 ); 

   950                     if ( iSdpParser->VideoControlAddr().Length() ) 

   951                         {

   952                         videoAddr.Set ( iSdpParser->VideoControlAddr() );

   953                         }

   954                     TPtrC8 audioAddr ( NULL , 0 );

   955                     if ( iSdpParser->AudioControlAddr().Length() ) 

   956                         {

   957                         audioAddr.Set ( iSdpParser->AudioControlAddr() );

   958                         }

   959                     

   960                     if ( iSdpParser->VideoControlAddr().Length() && 

   961                         rtpInfo.iFirstURL.Length() &&

   962                         videoAddr.Find( rtpInfo.iFirstURL ) >= 0 )

   963                         {

   964                         iRTPTimeStampVideo = rtpInfo.iFirstTS ? rtpInfo.iFirstTS : 1;

   965                         iSeqFromRtpInfoForVideo = rtpInfo.iFirstSeq;

   966                         }

   967                     if ( iSdpParser->VideoControlAddr().Length() && 

   968                          rtpInfo.iSecondURL.Length() &&

   969                          videoAddr.Find( rtpInfo.iSecondURL ) >= 0 )

   970                         {

   971                         iRTPTimeStampVideo = rtpInfo.iSecondTS ? rtpInfo.iSecondTS : 1;

   972                         iSeqFromRtpInfoForVideo = rtpInfo.iSecondSeq;

   973                         }

   974                     if ( iSdpParser->AudioControlAddr().Length() && 

   975                          rtpInfo.iFirstURL.Length() &&

   976                          audioAddr.Find( rtpInfo.iFirstURL) >= 0 )

   977                         {

   978                         iRTPTimeStampAudio = rtpInfo.iFirstTS ? rtpInfo.iFirstTS : 1;

   979                         iSeqFromRtpInfoForAudio = rtpInfo.iFirstSeq;

   980                         }

   981                     if ( iSdpParser->AudioControlAddr().Length() && 

   982                          rtpInfo.iSecondURL.Length() &&

   983                          audioAddr.Find( rtpInfo.iSecondURL) >= 0 )

   984                         {

   985                         iRTPTimeStampAudio = rtpInfo.iSecondTS ? rtpInfo.iSecondTS : 1;

   986                         iSeqFromRtpInfoForAudio = rtpInfo.iSecondSeq;

   987                         }

   988 

   989                     // ok, if we don't have rtp-info header, we don't know yet.

   990                     if (  rtpInfo.iFirstURL.Length() == 0 &&

   991                           rtpInfo.iSecondURL.Length() == 0 )

   992                         {

   993                         iNoRtpInfoHeader++;

   994                         }

   995                     else    

   996                         {

   997                         // We have RTP-info, so control stream is no longer mandatory

   998                         // Mark control streams as "found"                        

   999                         StreamFound( EAudioControlStream );

  1000                         StreamFound( EVideoControlStream );

  1001                         //StreamFound( ESubTitleControlStream );

  1002                         

  1003                         iSessionObs.StatusChanged( 

  1004                             MCRPacketSource::ERtpStateSeqAndTSAvailable );

  1005                         }

  1006                     

  1007                     // Live state

  1008                     if ( iResponses[ERTSPPlaySent]->IsLiveStream() || iSdpParser->IsLiveStream() ) 

  1009                         {

  1010                         if ( iObserver )

  1011                             {

  1012                             iObserver->ConnectionStatusChange(

  1013                                 iOwningSession.SourceChecksum(),

  1014                                 ECRStreamIsLiveStream, KErrNone );

  1015                             }

  1016                         }

  1017                     

  1018                     // Notify seeking

  1019                     if ( iObserver )

  1020                         {

  1021                         iObserver->ConnectionStatusChange(

  1022                             iOwningSession.SourceChecksum(),

  1023                             ECRReadyToSeek, KErrNone );

  1024                         }

  1025                     }

  1026                     break;

  1027                     

  1028             default:

  1029                 // by default extract no information

  1030                 break;

  1031                 }

  1032                 

  1033             // Then continue with business:

  1034             SendRtspCommandL(); // will change iStage also

  1035             }

  1036             

  1037         // Authentication needed..

  1038         else if ( iResponses[iStage]->StatusCode() ==  

  1039                   CCRRtspResponse::ERTSPRespUnauthorized || // 401

  1040                   iResponses[iStage]->StatusCode() ==

  1041                   CCRRtspResponse::ERTSPRespProxyAuthenticationRequired )  // 407

  1042             {

  1043             iAuthFailedCount++;

  1044             if ( iUserName && 

  1045                  iUserName->Length() && 

  1046                  iPassword && 

  1047                  iAuthFailedCount == 1 )

  1048                 {

  1049                 iAuthenticationNeeded = ETrue;

  1050                 iAuthType = iResponses[iStage]->AuthenticationTypeL().AllocL();

  1051                 iRealm = iResponses[iStage]->RealmL().AllocL();

  1052                 iOpaque = iResponses[iStage]->OpaqueL().AllocL();

  1053                 iNonce = iResponses[iStage]->NonceL().AllocL();

  1054                 SendAuthDescribeL();

  1055                 }

  1056             else

  1057                 {

  1058                 iAuthFailedCount = 0;

  1059                 LOG( "CCRRtspPacketSource::ProcessRtspResponseL() Authentication failure !" );

  1060                 

  1061                 // Cleanup

  1062                 iOwningSession.SourceStop();

  1063                 if ( iObserver )

  1064                     {

  1065                     iObserver->ConnectionStatusChange(

  1066                         iOwningSession.SourceChecksum(), 

  1067                         ECRAuthenticationNeeded, KErrNone );

  1068                     }

  1069                 }

  1070             }

  1071         else if ( iResponses[iStage]->StatusCode() ==  CCRRtspResponse::ERTSPRespUnsupportedTransport )  // 461

  1072             {            

  1073             LOG1( "CCRRtspPacketSource::ProcessRtspResponseL() - Unsupported Transport: %d", iTransport );

  1074                         

  1075             if ( iConnection.GetHeuristic( CCRConnection::EUdpStreamingBlocked ) )

  1076                 {

  1077                 // Using TCP, change to UDP                                

  1078                 LOG( "CCRRtspPacketSource::ProcessRtspResponseL() - Change TCP to UDP" );

  1079                 iConnection.SetHeuristic( CCRConnection::EUdpStreamingBlocked, EFalse );                

  1080                 // Notify observer at client side:

  1081                 ProcessRtspErrorResponseL( iResponses[iStage]->StatusCode() );

  1082                 }

  1083             else

  1084                 {

  1085                 // Using UDP, change to TCP

  1086                 LOG( "CCRRtspPacketSource::ProcessRtspResponseL() - Change UDP to TCP");

  1087                 iConnection.SetHeuristic( CCRConnection::EUdpStreamingBlocked, ETrue );

  1088                 // Notify observer at client side:

  1089                 ProcessRtspErrorResponseL( iResponses[iStage]->StatusCode() );

  1090                 }

  1091             }

  1092         else

  1093             {

  1094             // before doing cleanup, notify observer at client side:

  1095             ProcessRtspErrorResponseL( iResponses[iStage]->StatusCode() );

  1096             }

  1097         }

  1098     }

  1099 

  1100 // -----------------------------------------------------------------------------

  1101 // CCRRtspPacketSource::ProcessRtspErrorResponseL

  1102 // -----------------------------------------------------------------------------

  1103 //

  1104 void CCRRtspPacketSource::ProcessRtspErrorResponseL(

  1105     CCRRtspResponse::TResponseCode aErrorCode )

  1106     {

  1107     SCRQueueEntry entry;

  1108     entry.iMsg = ECRMsgQueueConnectionError;

  1109 

  1110     switch ( aErrorCode )

  1111         {

  1112         case CCRRtspResponse::ERTSPRespLowOnStorageSpace:

  1113             entry.iErr = KErrGeneral;

  1114             break;

  1115         

  1116         case CCRRtspResponse::ERTSPRespMultipleChoices:

  1117             entry.iErr = KErrGeneral;

  1118             break;

  1119         

  1120         case CCRRtspResponse::ERTSPRespMovedPermanently:

  1121             entry.iErr = KErrNotFound;

  1122             break;

  1123         

  1124         case CCRRtspResponse::ERTSPRespMovedTemporarily:

  1125             entry.iErr = KErrNotFound;

  1126             break;

  1127         

  1128         case CCRRtspResponse::ERTSPRespSeeOther:

  1129             entry.iErr = KErrGeneral;

  1130             break;

  1131         

  1132         case CCRRtspResponse::ERTSPRespNotModified:

  1133             entry.iErr = KErrGeneral;

  1134             break;