/*

* 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:    Class for streaming session. Owns a source, number of buffers*

*/

// INCLUDES

#include "VideoServiceUtilsConf.hrh"

#include "CCRStreamingSession.h"

#include "CCRRtspSink.h"

#include "CCRNullSink.h"

#include "CCRPacketBuffer.h"

#include <ipvideo/CRTypeDefs.h>

#include "CCRRtspPacketSource.h"

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

#include "CCRXpsSink.h"

#include "CCRRtpRecordSink.h"

#include "CCRRtpFileSource.h"

#include "CCRNullSource.h"

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

#include "MCRStreamObserver.h"

#include "CCRPacketSinkBase.h"

#include "CCRConnection.h"

#include "CCRengine.h"

#include "videoserviceutilsLogger.h"

// CONSTANTS

const TInt KMaxRtspPackets( 400 );

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

const TInt KMaxRtpPackets( 500 );

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

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

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

// CCRStreamingSession::NewL

//

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

//      

CCRStreamingSession* CCRStreamingSession::NewL(

    RSocketServ& aSockServer,

    CCRConnection* aConnection,

    CCREngine& aEngine )

    {

    CCRStreamingSession* self = new( ELeave ) CCRStreamingSession(

                                aSockServer, aConnection, aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCRStreamingSession::CCRStreamingSession

//

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

//      

CCRStreamingSession::CCRStreamingSession(

    RSocketServ& aSockServer,

    CCRConnection* aConnection,

    CCREngine& aEngine ) 

  : iSockServer( aSockServer ),

    iConnection( aConnection ),

    iEngine( aEngine )

    {

    // None

    }

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

// CCRStreamingSession::ConstructL

//

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

//          

void CCRStreamingSession::ConstructL()

    {

    LOG( "CCRStreamingSession::ConstructL()" );

    // Note, quite high priority

    iCleanUp = new ( ELeave ) CAsyncCallBack( CActive::EPriorityStandard ); 

    }

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

// CCRStreamingSession::~CCREStreamingSession

//

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

//          

CCRStreamingSession::~CCRStreamingSession()

    {

    LOG( "CCRStreamingSession::~CCRStreamingSession()" );

    delete iCleanUp;     

    iSinks.ResetAndDestroy();

    iSinksToDelete.Reset(); 

    delete iSource;

    delete iBuffer;

    iConnection = NULL;

    }

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

// CCRStreamingSession::OpenSourceL

// Opens RTSP streaming source.

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

//      

void CCRStreamingSession::OpenSourceL(

    const SCRRtspParams& aParams,

    const TDesC& aSessionDefinition )

    {

    LOG( "CCRStreamingSession::OpenSourceL(), RTSP Url" )

    if ( !iSource && iConnection )

        {

        iSourceChecksum = SourceDefinition( aSessionDefinition );

        iSource = CCRRtspPacketSource::NewL(

                  aParams, *iConnection, iSockServer, *this, *this );

        iSource->RegisterConnectionObs( &iEngine );

        }    

    }

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

// CCRStreamingSession::OpenSourceL

// Opens RTP clip streaming source.

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

//      

void CCRStreamingSession::OpenSourceL(

    const SCRRtpPlayParams& aParams,

    CRtpClipHandler*& aClipHandler,

    const TDesC& aSessionDefinition )

    {

    LOG( "CCRStreamingSession::OpenSourceL(), RTP clip" )

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

    if ( !iSource )

        {

        iSourceChecksum = SourceDefinition( aSessionDefinition );

        iBuffer = CCRPacketBuffer::NewL( KMaxRtpPackets );

        iSource = CCRRtpFileSource::NewL( aParams, aClipHandler, *this, *this );

        iSource->SetBuffer( iBuffer );

        }

#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    ( void )aParams;

    ( void )aClipHandler;

    ( void )aSessionDefinition;

    User::Leave( KErrNotSupported );

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    }

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

// CCRStreamingSession::OpenSourceL

// Opens RTP clip streaming source.

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

//      

void CCRStreamingSession::OpenSourceL(

    const RFile& aRtpHandle,

    CRtpClipHandler*& aClipHandler,

    const TDesC& aSessionDefinition )

    {

    LOG( "CCRStreamingSession::OpenSourceL(), RTP handle" )

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

    if ( !iSource )

        {

        iSourceChecksum = SourceDefinition( aSessionDefinition );

        iBuffer = CCRPacketBuffer::NewL( KMaxRtpPackets );

        iSource = CCRRtpFileSource::NewL( aRtpHandle, aClipHandler, *this, *this );

        iSource->SetBuffer( iBuffer );

        }

#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    ( void )aRtpHandle;

    ( void )aClipHandler;

    ( void )aSessionDefinition;

    User::Leave( KErrNotSupported );

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    }

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

// CCRStreamingSession::OpenSourceL

// Opens DVB-H live streaming source.

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

//      

void CCRStreamingSession::OpenSourceL(

    const SCRLiveParams& /*aLiveParams*/,

    const TDesC& /*aSessionDefinition*/ )

    {

    LOG( "CCRStreamingSession::OpenSourceL(), DVB-H live" )

    User::Leave( KErrNotSupported );

    }

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

// CCRStreamingSession::OpenSourceL

// Opens RTP clip as a live streaming source.

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

//      

void CCRStreamingSession::OpenSourceL( const TDesC& aSessionDefinition )

    {

    LOG( "CCRStreamingSession::OpenSourceL(), Null" )

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

    if ( !iSource )

        {

        iSourceChecksum = SourceDefinition( aSessionDefinition );

        iBuffer = CCRPacketBuffer::NewL( KMaxRtpPackets );

        iSource = CCRNullSource::NewL( aSessionDefinition, *this, *this );

        iSource->SetBuffer( iBuffer );

        }

#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    ( void )aSessionDefinition;

    User::Leave( KErrNotSupported );

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    }

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

// CCRStreamingSession::SourceDefinition

//

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

//      

TUint CCRStreamingSession::SourceDefinition( const TDesC& aName )

    {

    TUint checkSum( 0 );

    for ( TInt i( aName.Length() - 1 ); i >= 0; i-- )

        {

        checkSum += aName[i];

        }

	// And for rtsp packet source do use different id

	// if udp is blocked and we're using tcp then.    

    if ( iSource && iSource->Id() == ECRRtspSourceId &&

    	 iConnection && 

    	 iConnection->GetHeuristic ( CCRConnection::EUdpStreamingBlocked ) )

    	 {

    	 checkSum++;

    	 }

    return checkSum;

    }

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

// CCRStreamingSession::SourceChecksum

//

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

//      

TUint CCRStreamingSession::SourceChecksum()

    {

    return iSourceChecksum;

    }

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

// CCRStreamingSession::CreateAndSetBufferL

//

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

//    

void CCRStreamingSession::CreateAndSetBufferL()

    {

    if ( iSource && iBuffer == NULL )

        {

        iBuffer = CCRPacketBuffer::NewL( KMaxRtspPackets );

        iSource->SetBuffer( iBuffer );

        }

    }

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

// CCRStreamingSession::CreateRtspSinkL

//

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

//

void CCRStreamingSession::CreateRtspSinkL( const TInt& aLoopbackPort )

    {

    LOG( "CCRStreamingSession::CreateRtspSinkL()" )

    if ( iConnection )

        {

        // Only one RTSP sink at the time

        DeleteSink( ECRRtspSinkId ); 

        // New sink

        CCRRtspSink* sink = CCRRtspSink::NewL(

            *iConnection, iSockServer, ECRRtspSinkId, aLoopbackPort, *this );

        CleanupStack::PushL( sink );

        User::LeaveIfError( iSinks.Append( sink ) );

        CleanupStack::Pop( sink );

        }

    }

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

// CCRStreamingSession::CreateXpsSinkL

//

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

//    

void CCRStreamingSession::CreateXpsSinkL()

    {

    LOG( "CCRStreamingSession::CreateXpsSinkL()" )

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

    CCRXpsSink* sink = CCRXpsSink::NewL( ECRXpsSinkId, *this );

    CleanupStack::PushL( sink );

    User::LeaveIfError( iSinks.Append( sink ) );

    CleanupStack::Pop( sink );

#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    User::Leave( KErrNotSupported );

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    }

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

// CCRStreamingSession::Create3gpRecordSinkL

//

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

//    

void CCRStreamingSession::Create3gpRecordSinkL(

    const SCRRecordParams& /*aRecordParams*/ )

    {

    LOG( "CCRStreamingSession::Create3gpRecordSinkL()" )

    User::Leave( KErrNotSupported );

    /*

    CCR3gpRecordSink* sink = CCR3gpRecordSink::NewL( ECR3gpRecSinkId, *this );

    CleanupStack::PushL( sink );

    User::LeaveIfError( iSinks.Append( sink ) );

    CleanupStack::Pop( sink );

    */

    }

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

// CCRStreamingSession::CreateRtpRecordSinkL

//

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

//    

void CCRStreamingSession::CreateRtpRecordSinkL(

    const SCRRecordParams& aRecordParams,

    CRtpClipHandler*& aClipHandler )

    {

    LOG( "CCRStreamingSession::CreateRtpRecordSinkL()" )

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

    // Create record sink

    CCRRtpRecordSink* sink = CCRRtpRecordSink::NewL( 

        aRecordParams, ECRRtpRecSinkId, *this, &iEngine, aClipHandler );

    CleanupStack::PushL( sink );

    User::LeaveIfError( iSinks.Append( sink ) );

    CleanupStack::Pop( sink );

#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    ( void )aRecordParams;

    ( void )aClipHandler;

    User::Leave( KErrNotSupported );

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    }

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

// CCRStreamingSession::PostActionL

//

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

//    

void CCRStreamingSession::PostActionL()

    {

    User::LeaveIfNull( iSource );

    iSource->PostActionL();

    }

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

// CCRStreamingSession::PlayCommand

//

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

//    

TInt CCRStreamingSession::PlayCommand(

    const TReal& aStartPos,

    const TReal& aEndPos )

    {

    if ( iSource )

        {

        return iSource->Play( aStartPos, aEndPos );

        }

    return KErrCompletion;

    }

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

// CCRStreamingSession::PauseCommand

//

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

//    

TInt CCRStreamingSession::PauseCommand()

    {

    if ( iSource )

        {

        return iSource->Pause();

        }

    return KErrCompletion;

    }

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

// CCRStreamingSession::StopCommand

//

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

//    

TInt CCRStreamingSession::StopCommand()

    {

    if ( iSource && iSinks.Count() >= 1 )

        {

        return iSource->Stop();

        }

    return KErrCompletion;

    }

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

// CCRStreamingSession::SetPosition

//

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

//    

TInt CCRStreamingSession::SetPosition( const TInt64 aPosition )

    {

    if ( iSource )

        {

        return iSource->SetPosition( aPosition );

        }

    return KErrCompletion;

    }

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

// CCRStreamingSession::GetPosition

//

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

//    

TInt CCRStreamingSession::GetPosition( TInt64& aPosition, TInt64& aDuration )

    {

    if ( iSource )

        {

        return iSource->GetPosition( aPosition, aDuration );

        }

    return KErrCompletion;

    }

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

// CCRStreamingSession::PauseCommand

//

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

//    

TInt CCRStreamingSession::PauseCommand( const TCRSinkId& aSinkId )

    {

    // Pauses current sink action

    for ( TInt i( iSinks.Count() - 1 ); i >= 0; i-- )

        {

        if ( aSinkId == iSinks[i]->Id() )

            {

            return iSinks[i]->Pause();

            }

        }

    return KErrCompletion;

    }

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

// CCRStreamingSession::RestoreCommand

//

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

//    

TInt CCRStreamingSession::RestoreCommand( const TCRSinkId& aSinkId )

    {

    // Pauses current sink action

    for ( TInt i( iSinks.Count() - 1 ); i >= 0; i-- )

        {

        if ( aSinkId == iSinks[i]->Id() )

            {

            return iSinks[i]->Restore();

            }

        }

    return KErrCompletion;

    }

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

// CCRStreamingSession::StopCommand

//

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

//    

TInt CCRStreamingSession::StopCommand( const TCRSinkId& aSinkId )

    {

    // Stop current sink action

    for ( TInt i( iSinks.Count() - 1 ); i >= 0; i-- )

        {

        if ( aSinkId == iSinks[i]->Id() )

            {

            iSinks[i]->Stop();

            return KErrNone;

            }

        }

    return KErrCompletion;

    }

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

// CCRStreamingSession::TransferSink

//

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

//    

TInt CCRStreamingSession::TransferSink(

    const TCRSinkId& aSinkId,

    CCRStreamingSession& aTargetSession )

    {

    LOG1( "CCRStreamingSession::TransferSink(), aSinkId: %d", aSinkId );

    for ( TInt i( iSinks.Count() - 1 ); i >= 0; i-- )

        {

        if ( iSinks[i]->Id() == aSinkId )

            {