/*

* 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:    Implementation of the DVB-H Recording Manager RTP read class.*

*/

// INCLUDE FILES

#include "CRtpToFile.h"

#include "CRtpFromFile.h"

#include <ipvideo/CRtpMetaHeader.h>

#include <ipvideo/CRtpClipManager.h>

#include "CRtpTimer.h"

#include <bsp.h>

#include "videoserviceutilsLogger.h"

// CONSTANTS

const TInt KReadTimerInterval( 1000 );

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

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

// CRtpFromFile::NewL

// Static two-phased constructor. Leaves object to cleanup stack.

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

//

CRtpFromFile* CRtpFromFile::NewL( 

    MRtpFileReadObserver& aReadObs,

    CRtpToFile* aToFile )

    {

    CRtpFromFile* self = new( ELeave ) CRtpFromFile( aReadObs, aToFile );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CRtpFromFile::CRtpFromFile

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

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

//

CRtpFromFile::CRtpFromFile( MRtpFileReadObserver& aReadObs, CRtpToFile* aToFile )

  : CRtpFileBase(),

    iReadObs( aReadObs ),

    iToFile( aToFile ),

    iSkippedRead( EFalse ),

    iDuration( 0 )

    {

    // None

    }

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

// CRtpFromFile::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRtpFromFile::ConstructL()

    {

    LOG( "CRtpFromFile::ConstructL()" );

    CRtpFileBase::ConstructL();

    }

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

// Destructor

//

CRtpFromFile::~CRtpFromFile()

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

    {

    LOG( "CRtpFromFile::~CRtpFromFile()" );

    Cancel();

    delete iTimer; iTimer = NULL;

    delete iFileData; iFileData = NULL;

    }

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

// CRtpFromFile::InitRtpReadL

// Sets path of RTP file.

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

//

void CRtpFromFile::InitRtpReadL(

    const TDesC& aClipPath,

    TInt8& aVersion,

    const TBool aTimeShift )

    {

    LOG1( "CRtpFromFile::InitRtpReadL(), aClipPath: %S", &aClipPath );

    // File server

    if ( !iFs.Handle() )

        {

        User::LeaveIfError( iFs.Connect() );

        }

    // Open clip

    aVersion = SwapClipL( aClipPath );

    // Mode

    iMode = ( aTimeShift )? EModeTimeShift: EModeNormal;

#ifdef CR_ALL_LOGS

    LogVariables( _L( "InitRtpReadL()" ) );

#endif // CR_ALL_LOGS

    }

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

// CRtpFromFile::InitRtpReadL

// Sets path of RTP file.

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

//

void CRtpFromFile::InitRtpReadL(

    const RFile& aFileHandle,

    TInt8& aVersion )

    {

    LOG( "CRtpFromFile::InitRtpReadL(), with handle" );

    // File handle

    if ( !iFs.Handle() )

        {

        User::LeaveIfError( iFs.Connect() );

        }

    // Duplicate handle

    iFile.Close();

    iFile.Duplicate( aFileHandle );

    // File header

    ReadClipHeaderL( aVersion );

    delete iCurrentPath; iCurrentPath = NULL;

    TFileName name( KNullDesC );

    iFile.FullName( name );

    iCurrentPath = name.AllocL();

    // Mode

    iMode = EModeNormal;

#ifdef CR_ALL_LOGS

    LogVariables( _L( "InitRtpReadL()" ) );

#endif // CR_ALL_LOGS

    }

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

// CRtpFromFile::SwapClipL

// Sets new path of RTP file.

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

//

TInt8 CRtpFromFile::SwapClipL( const TDesC& aClipPath )

    {

    LOG1( "CRtpFromFile::SwapClipL(), aClipPath: %S", &aClipPath );

    iFile.Close();

    if ( !iFs.Handle() )

        {

        User::Leave( KErrBadHandle );

        }

    // Delete used clip

    if ( iMode == EModeTimeShift )

        {

        iFs.Delete( *iCurrentPath );

        }

    // Open new

    User::LeaveIfError( iFile.Open( iFs, aClipPath,

                        EFileShareAny | EFileStream | EFileRead ) );

    // File header

    TInt8 version( 0 );

    ReadClipHeaderL( version );

    delete iCurrentPath; iCurrentPath = NULL;

    iCurrentPath = aClipPath.AllocL();

    return version;

    }

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

// CRtpFromFile::ReadNextGroupL

// Reads next RTP packets group from a specified file.

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

//

TInt CRtpFromFile::ReadNextGroupL( const TInt aGroupPoint )

    {

    User::LeaveIfError( iMode );

    TBool delayedRead( EFalse );

    // Allready active??

    if ( iFileData )

        {

        if ( iTimer || IsActive() )

            {

            return KErrInUse; // Read already started, indication, not error

            }

        else

            {

            // Packet read may happen during iReadObs.RtpGroupReaded() call

            LOG( "CRtpFromFile::ReadNextGroupL(), Delayed read !" );

            delayedRead = ETrue;

            }

        }

    // Is watch during recording too close to live?

    if ( iToFile && iNextGroupPoint >= LastSeekAddr() )

        {

        iSkippedRead = ETrue;

        LOG( "CRtpFromFile::ReadNextGroupL(), Too close to live !" );

        return KErrEof; // No read actions now, indication, not error

        }

    // Group

    iThisGroup = ( aGroupPoint > KErrNotFound )? aGroupPoint: iNextGroupPoint;

    // Ok to read more?

    if ( iThisGroup > iLastSeekAddr || iGroupTime >= iDuration )

        {

        LOG( "CRtpFromFile::ReadNextGroupL(), All packets readed !" );

        User::Leave( KErrEof );

        }

    // Read group

    if ( delayedRead )

        {

        delete iTimer; iTimer = NULL;

        iTimer = CRtpTimer::NewL( *this );

        iTimer->After( KReadTimerInterval );

        }

    else

        {

        ReadGroupHeaderL();

        ReadNextGroupFromFileL();

        }

    return KErrNone;

    }

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

// CRtpFromFile::GetClipSdpL

// Reads SDP from a current clip. SDP is stored to meta header during recording.

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

//

HBufC8* CRtpFromFile::GetClipSdpL()

    {

    User::LeaveIfError( iMode );

    CRtpMetaHeader* metaheader = CRtpMetaHeader::NewLC(

                                 iFile, CRtpMetaHeader::EMetaRead );

    HBufC8* sdp = metaheader->ReadSdpDataL();

    CleanupStack::PopAndDestroy( metaheader );

    return sdp;

    }

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

// CRtpFromFile::ReadSkippedGroup

// Reads one RTP packet from a specified file if previous read was skipped.

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

//

void CRtpFromFile::ReadSkippedGroup()

    {

    if ( iSkippedRead && iNextGroupPoint < LastSeekAddr() &&

         iMode != EModeNone && iFileData != NULL )

        {

        iSkippedRead = EFalse;

        iThisGroup = iNextGroupPoint;

        TRAP_IGNORE( ReadGroupHeaderL();

                     ReadNextGroupFromFileL() );

        }

    }

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

// CRtpFromFile::UpdateLastSeekAddr

// Updates final last seek addres from clip write when recording stopped.

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

//

void CRtpFromFile::UpdateLastSeekAddr()

    {

    if ( iToFile )

        {

        iDuration = iToFile->GetCurrentLength();

        iLastSeekAddr = iToFile->LastSeekAddr();

        LOG2( "CRtpFromFile::UpdateLastSeekAddr(), iLastSeekAddr: %d, iDuration: %d",

                                                   iLastSeekAddr, iDuration ); 

        // Recording is stopped

        iToFile = NULL;

        }

    }

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

// CRtpFromFile::SetSeekPointL

// Sets the seek point of the clip.

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

//

void CRtpFromFile::SetSeekPointL( const TUint aTime )

    {

    Cancel();

    delete iTimer; iTimer = NULL;

    delete iFileData; iFileData = NULL;

    User::LeaveIfError( iMode );

    // Group from the seek array, accuracy 30s

    iThisGroup = FindSeekGroup( aTime, ( iToFile )? iToFile->SeekArray(): iSeekArray );

    LOG2( "CRtpFromFile::SetSeekPointL(), aTime: %d, group from seek array: %d", 

                                          aTime, iThisGroup );

    if ( iThisGroup == KErrNotFound )

        {

        iThisGroup = iFirstSeekAddr;

        }

    ReadGroupHeaderL();

    // Find group basing on the seek time, accuracy 0 - 3 s

    if ( aTime > 0 )

        {

        while ( aTime > iGroupTime && iNextGroupPoint < iLastSeekAddr )

            {

            // Next group

            iThisGroup = iNextGroupPoint;

            ReadGroupHeaderL();

#ifdef CR_ALL_LOGS

            LOG2( "CRtpFromFile::SetSeekPointL(), iThisGroup: %u, iGroupTime: %u", 

                                                  iThisGroup, iGroupTime );

#endif // CR_ALL_LOGS

            }

        }

    // Prepare for next read, one extra group back looks better

    iNextGroupPoint = ( iPrevGroupPoint > iFirstSeekAddr ) ?

        iPrevGroupPoint : iThisGroup;

    delete iFileData; iFileData = NULL;

    LOG1( "CRtpFromFile::SetSeekPointL(), iNextGroupPoint: %d",

                                          iNextGroupPoint );

    }

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

// CRtpFromFile::StopRtpRead

// Stops file reading.

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

//

void CRtpFromFile::StopRtpRead( const TInt aStatus, const TUint aPlayerBuf )

    {

    LOG2( "CRtpFromFile::StopRtpRead(), aStatus: %d, aPlayerBuf: %u",

                                        aStatus, aPlayerBuf );

    LOG2( "CRtpFromFile::StopRtpRead(), iMode: %d, iGroupTime: %d",

                                        iMode, iGroupTime );

    Cancel();

    if ( iMode != EModeNone )

        {

        iFile.ReadCancel();

#ifdef CR_ALL_LOGS

        LogVariables( _L( "StopRtpRead()" ) );

#endif // CR_ALL_LOGS

        }

    delete iTimer; iTimer = NULL;

    delete iFileData; iFileData = NULL;

    if ( iMode == EModeNormal || iMode == EModeHandle )

        {

        // Try to seek back to what user sees for continue play spot

        if ( !aStatus & iThisGroup > 0 && iThisGroup < iLastSeekAddr )

            {

            const TInt thisGroup( iThisGroup );

            TRAPD( err, SetSeekPointL( iGroupTime - aPlayerBuf ) );

            if ( err )

                {

                LOG1( "CRtpFromFile::StopRtpRead(), SetSeekPointL Leaved: %d", err ); 

                iThisGroup = thisGroup;

                }

            }

        // Update meta header if no error

        if ( !aStatus )

            {

            TInt err ( KErrNone );

            if ( iToFile )

                {

                TRAP( err, iToFile->UpdatePlayAttL( iThisGroup ) );

                }

            else

                {

                TRAP( err, UpdatePlayAttL() );

                }

            // Possible error ignored

            if ( err )

                {

                LOG1( "CRtpFromFile::StopRtpRead(), UpdatePlayAttL Leaved: %d", err ); 

                }

            }

        }

    iMode = EModeNone;

    iFile.Close();

    }

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

// CRtpFromFile::RunL

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

//

void CRtpFromFile::RunL()

    {

    User::LeaveIfError( iStatus.Int() );

    // All groups readed?

    if ( iThisGroup >= iLastSeekAddr ||

       ( iNextGroupPoint >= iLastSeekAddr &&

         iToFile && iToFile->Action() == MRtpFileWriteObserver::ESavePause ) )

        {

        LOG2( "CRtpFromFile::RunL(), All groups readed ! total: %d, iDuration: %d",

                                                         iThisGroup, iDuration ); 

        iGroupTime = iDuration;

        }

    iReadObs.GroupReadedL( iDataPtr, iGroupTime, ( iGroupTime >= iDuration ) );

    delete iFileData; iFileData = NULL;

    }

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

// CRtpFromFile::RunError

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

//

TInt CRtpFromFile::RunError( TInt aError )

    {

    LOG1( "CRtpFromFile::RunError(), RunL Leaved: %d", aError );

    iReadObs.ReadStatus( aError );

    StopRtpRead( aError, 0 );

    return KErrNone;

    }

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

// CRtpFromFile::DoCancel

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

//

void CRtpFromFile::DoCancel()

    {

    LOG( "CRtpFromFile::DoCancel()" );

    }

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

// CRtpFromFile::TimerEventL

// Internal timer call this when triggered.

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

//

void CRtpFromFile::TimerEventL()

    {

    LOG( "CRtpFromFile::TimerEventL() in" );

    ReadGroupHeaderL();

    ReadNextGroupFromFileL();

    delete iTimer; iTimer = NULL;

    LOG( "CRtpFromFile::TimerEventL() out" );

    }

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

// CRtpFromFile::TimerError

// Internal timer call this when TimerEventL() leaves.

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

//

void CRtpFromFile::TimerError( const TInt aError )

    {

    LOG1( "CRtpFromFile::TimerError(), TimerEventL Leaved: %d", aError );

    StopRtpRead( aError, 0 );

    delete iTimer; iTimer = NULL;

    }

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

// CRtpFromFile::ReadClipHeaderL

// Reads meta data and seek header from the beginning of the file.

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

//

void CRtpFromFile::ReadClipHeaderL( TInt8& aVersion )

    {

    LOG1( "CRtpFromFile::ReadClipHeaderL(), iToFile: %d", iToFile );

    if ( !iToFile )

        {

        TInt seekArrayPoint( KErrNotFound );

        aVersion = ReadMetaHeaderL( iSeekHeaderPoint, seekArrayPoint );

        ReadSeekHeaderL();

        // Read seek array if exist

        if ( seekArrayPoint > iLastSeekAddr )

            {

            ReadSeekArrayL( seekArrayPoint );

            }

        }

    else // Recording ongoing with the same clip

        {

        aVersion = KCurrentClipVersion;

        iSeekHeaderPoint = iToFile->SeekHeaderPoint();

        iGroupsTotalCount = iToFile->GroupsTotalCount();

        iFirstSeekAddr = iToFile->FirstSeekAddr();

        iLastSeekAddr = iToFile->LastSeekAddr();

        }

    iNextGroupPoint = iFirstSeekAddr;

    }

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

// CRtpFromFile::ReadMetaHeaderL

// Reads meta data header from the beginning of the file.

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

//

TInt8 CRtpFromFile::ReadMetaHeaderL(

    TInt& aSeekHeaderPoint,

    TInt& aSeekArrayPoint )

    {

    CRtpMetaHeader* metaheader = CRtpMetaHeader::NewLC(

                                 iFile, CRtpMetaHeader::EMetaRead );

    aSeekHeaderPoint = metaheader->SeekHeaderPoint();

    metaheader->ReadSeekArrayPointL( aSeekArrayPoint );

    LOG2( "CRtpFromFile::ReadMetaHeaderL(), aSeekHeaderPoint: %d, aSeekArrayPoint: %d",

                                            aSeekHeaderPoint, aSeekArrayPoint );

    // Clip version

    CRtpMetaHeader::SAttributes att;