/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:    RTSP Client impl.*

*/

// INCLUDE FILES

#include "CCRRtspPacketSource.h"

#include "CCRPunchPacketSender.h"

#include "CCRRtpTcpStreamer.h"

#include "CCRRtspCommand.h"

#include "CCRPacketBuffer.h"

#include <ipvideo/CDvrSdpParser.h>

#include "CCRTimer.h"

#include <Uri16.h>

#include <e32msgqueue.h>

#include <centralrepository.h>

#include <WebUtilsInternalCRKeys.h>

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

// DATA TYPES

// ######################################################

// WARNING: JUMBOJET-SIZED KLUDGE AHEAD:

// ######################################################

#define private public

// Explanation: timestamp getter in rtcp sender report

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

// broken version is already shipped to millions of phones

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

// be overridden as it requires access to private part

// of sender reports instance variables. The item we

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

// variables but there is useless getter for that.

#include <rtcp.h>

/* sender report (SR) */

class TRtcpSRPart

    {

public:

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

    TUint32 ntp_sec;  /**< NTP timestamp */

    TUint32 ntp_frac; /**< Fractal seconds */

    TUint32 rtp_ts;   /**< RTP timestamp */

    TUint32 psent;    /**< packets sent */

    TUint32 osent;    /**< octets sent */

    };

#undef private

// ######################################################

// Major kludge ends here.

// ######################################################

// CONSTANTS

const TInt KCRPortNumberBase( 16670 );

const TInt KCSeqForRtspNegoation( 42 );

const TInt KRtspPortNumber( 554 );

const TInt KRtpPacketVersion( 2 ); 

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

const TInt KDVR10Seconds( 10000000 );

// The number of sequential packets that must be received

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

// from very first packet

const TInt KDVRMinSequential( 1 ); 

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

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

const TInt KDVRMaxMisorder( 50 ); 

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

// before it is considered dropped. 

const TInt KDVRMaxDropOut( 3000 ); 

_LIT( KRtspPortString, "554" );

_LIT8( KCRCName, "N++ " );

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

const TTimeIntervalMicroSeconds32 KCRRtspRtpUdpTimeout( 10 * 1e6 );

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

const TTimeIntervalMicroSeconds32 KCRRtspResponseTimeout( 15 * 1e6 );

// Timeout for waiting for server response to TIERDOWN command

const TTimeIntervalMicroSeconds32 KCRRtspTierdownTimeout( 3 * 1e6 );

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

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CCRRtspPacketSource* CCRRtspPacketSource::NewL(

    const SCRRtspParams& aParams,

    CCRConnection& aConnection,

    RSocketServ& aSockServer,

    MCRStreamObserver& aSessionObs,

    CCRStreamingSession& aOwningSession )

    {

    CCRRtspPacketSource* self = new( ELeave )

        CCRRtspPacketSource( aConnection, aSockServer, aSessionObs, aOwningSession );

    CleanupStack::PushL( self );

    self->ConstructL( aParams );

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::CCRRtspPacketSource

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

// -----------------------------------------------------------------------------

//

CCRRtspPacketSource::CCRRtspPacketSource(

    CCRConnection& aConnection,

    RSocketServ& aSockServer,

    MCRStreamObserver& aSessionObs,

    CCRStreamingSession& aOwningSession )

  : CCRPacketSourceBase( aOwningSession, CCRStreamingSession::ECRRtspSourceId ),

    iSockServer( aSockServer ),

    iConnection( aConnection ),

    iStage( ERTSPInit ),

    iCSeq( KCSeqForRtspNegoation ),

    iClientPort( KCRPortNumberBase ),

    iSessionId(NULL, 0 ),

    iReadyToPlay(EFalse),

    iSessionObs( aSessionObs ),

    iStartPos( KRealZero ),

    iEndPos( KRealMinusOne ),

    iUdpFound( EFalse ),

    iTrafficFound( EFalse )

    {

    // None

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CCRRtspPacketSource::ConstructL( const SCRRtspParams& aParams )

    {

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

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

        {

        User::Leave ( KErrArgument ); 

        }

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

    iRtpTcpStreamer = CCRRtpTcpStreamer::NewL( *this );

    iRtspUri = aParams.iUrl.AllocL();

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

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

    iUserName = aParams.iUserName.AllocL();

    iPassword = aParams.iPassword.AllocL();

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

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

    iProxyServerAddr = aParams.iProxyServerAddr; 

    iProxyServerPort = aParams.iProxyServerPort; 

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

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

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::~CCRRtspPacketSource

// Destructor.

// -----------------------------------------------------------------------------

//

CCRRtspPacketSource::~CCRRtspPacketSource()

    {

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

    // Deletes everything related to session

    CleanUp();

    delete iRtspTimeout;

    delete iSentData;

    delete iAuthType;

    delete iRtspUri8;

    delete iUserName;

    delete iPassword;

    delete iNonce;

    delete iOpaque;

    delete iRealm;

    delete iRtpTcpStreamer;

    delete iUdpReceptionTimer;

    iReceiveStreams.Reset();

    iObserver = NULL;

    iConnection.UnregisterObserver( this );

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

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::CleanUp

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

// cleanup method.

// -----------------------------------------------------------------------------

//

void CCRRtspPacketSource::CleanUp()

    {

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

    if ( iUdpReceptionTimer )

        {

        iUdpReceptionTimer->Cancel();

        }

    delete iRtspPingTimer;

    iRtspPingTimer = NULL;

    iRtpRecvSrcAudio.Close();

    iRtpRecvSrcVideo.Close();

    iAudioSession.Close();

    iVideoSession.Close();

    iReadyToPlay = EFalse;

    delete iSdpParser; iSdpParser = NULL;

    delete iRtspUri; iRtspUri = NULL;

    delete iRtspSock; iRtspSock = NULL;

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

        {

        delete iRTPSockArr[i];

        iRTPSockArr[i] = NULL;

        }

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

        {

        delete iPrevCommands[i];

        iPrevCommands[i] = NULL;

        delete iResponses[i];

        iResponses[i] = NULL;

        }

    iSessionId.Set( NULL, 0 );

    delete iPunchPacketSenderAudio; iPunchPacketSenderAudio = NULL;

    delete iPunchPacketSenderVideo; iPunchPacketSenderVideo = NULL;

    delete iUserAgent; iUserAgent = NULL;

    delete iWapProfile; iWapProfile = NULL;

    iStartPos = KRealZero;

    iEndPos = KRealMinusOne;

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

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::DoConnectL

// -----------------------------------------------------------------------------

//

void CCRRtspPacketSource::DoConnectL( void )

    {

    if ( !iRtspUri )

        {

        User::Leave( KErrNotReady );

        }

    if ( iRtspSock )

        {

        delete iRtspSock; iRtspSock = NULL;

        }

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

                               iSockServer, ETrue, ETrue );

    TUriParser uriParser;

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

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

    TPtrC portString( KRtspPortString );

    if ( uriParser.IsPresent( EUriPort ) )

        {

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

        }

    TLex portLex( portString );

    TInt port( KRtspPortNumber );

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

        {

        User::Leave( KErrMMInvalidURL );

        }

    if ( iProxyServerAddr.Length() && iProxyServerPort )

        {

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

            &iProxyServerAddr, iProxyServerPort );

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

        }

    else

        {

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

        }

    iCSeq = KCSeqForRtspNegoation;

    TTime now;

    now.UniversalTime();

    iClientPort = 

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

    // Get transport method from connection heuristics

    iTransport = ( iConnection.GetHeuristic(

        CCRConnection::EUdpStreamingBlocked ) )? ERTPOverTCP: ERTPOverUDP;

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

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

    TConnMonBearerType bearer = iConnection.BearerType();

    TBool is3g( iConnection.IsBearerWLANor3G( bearer ) );

    // Fetch wap profile from WebUtils repository

    if ( !iWapProfile )

        {

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

        TUint32 profilekey = ( is3g )? KWebUtilsUaProf3G: KWebUtilsUaProf;

        TFileName profilebuf( KNullDesC );

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

            {

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

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

            }

        CleanupStack::PopAndDestroy( repository );

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

        }

    // Fetch user agent

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

    delete iUserAgent; iUserAgent = NULL;

    iUserAgent = KCRRTSPDefaultUserAgent().AllocL();

    // Get bandwidth from connection

    iBandwidth = iConnection.MaximumBandwidth();

    LOG( "CCRRtspPacketSource::DoConnectL out" );

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::URI

// -----------------------------------------------------------------------------

//

TPtr CCRRtspPacketSource::URI(void)

    {

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

    TPtr retval ( NULL , 0 );

    if ( iRtspUri ) 

        {

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

        }

    else

        {

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

        }

    return retval; 

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::GetSdp

// -----------------------------------------------------------------------------

//

TInt CCRRtspPacketSource::GetSdp( TPtrC8& aSdp )

    {

    TInt retval( KErrNotReady );

    if ( iSdpParser )

        {

        return iSdpParser->GetSdp( aSdp );

        }

    return retval;

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::SeqAndTS

// -----------------------------------------------------------------------------

//

TInt CCRRtspPacketSource::SeqAndTS(

    TUint& aAudioSeq,

    TUint& aAudioTS,

    TUint& aVideoSeq,

    TUint& aVideoTS )

    {

    TInt retval( KErrNotReady );

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

        {

        aAudioSeq = iSeqFromRtpInfoForAudio;

        aAudioTS = iRTPTimeStampAudio;

        aVideoSeq = iSeqFromRtpInfoForVideo;

        aVideoTS = iRTPTimeStampVideo;

        retval = KErrNone;

        }

    return retval;

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::PostActionL

// -----------------------------------------------------------------------------

//

void CCRRtspPacketSource::PostActionL()

    {

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

                                                                    iSdpParser );

    User::LeaveIfNull( iSdpParser );

    iSessionObs.StatusChanged( MCRPacketSource::ERtpStateSdpAvailable );

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::Play

// -----------------------------------------------------------------------------

//

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

    {

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

                                        aStartPos, aEndPos );

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

                                        iCSeq, iLastReceivedSeq );

    iReadyToPlay = ETrue;

    iStartPos = aStartPos;

    iEndPos = aEndPos;

    ResetStreamFlags();

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

    // instead setposition will be called 

    if ( iBuffer )

        {

        iBuffer->ResetBuffer();

        }    

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

    // need to open at least one of them:

    TInt err( KErrNone );

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

        {

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

            {

            TRAP( err, SendPlayCommandL() );

            }

        else

            { 

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

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

            // operation

            iPostPonedPlay = ETrue;

            }

        }

    return err;

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::Pause

// -----------------------------------------------------------------------------

//

TInt CCRRtspPacketSource::Pause()

    {

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

    TInt err( KErrNotReady );

    if ( iStage == ERTSPPlaying )

        {

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

            {

            err = KErrNotSupported;

            }

        else

            {

            TRAP( err, SendPauseCommandL() );

            }

        }

    if ( iStage == ERTSPPauseSent )

        {

        err = KErrNone;

        }

    return err;

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::Stop

// -----------------------------------------------------------------------------

//

TInt CCRRtspPacketSource::Stop()

    {

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

    iReadyToPlay = EFalse;

    iPostPonedPlay = EFalse;

    iStartPos = KRealZero;

    TInt err( KErrDisconnected );

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

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

         iStage == ERTSPSetupVideoSent )

        {

        err = KErrNone;

        if ( iRtspSock )

            {

            iRtspSock->Cancel();

            }

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

        iStage = ERTSPTearDownSent;

        StartRtspTimeout( KCRRtspTierdownTimeout );

        }

    return err;

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::SetPosition

// -----------------------------------------------------------------------------

TInt CCRRtspPacketSource::SetPosition( const TInt64 aPosition ) 

    {

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

    if ( aPosition == -2 )

        {

        if ( iStage != ERTSPPlaySent && iObserver )

            {

            iObserver->ConnectionStatusChange(

                iOwningSession.SourceChecksum(),

                ECRReadyToSeek, KErrNone );

            }

        }

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CCRRtspPacketSource::GetRange

// -----------------------------------------------------------------------------

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

    {

    aLower = KRealZero;

    aUpper = KRealMinusOne;

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

         iResponses[ERTSPPlaySent] )