/*

* 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 common recording engine file repairer class.*

*/

// INCLUDE FILES

#include "CRtpClipRepairer.h"

#include <ipvideo/CRtpMetaHeader.h>

#include <ipvideo/CRtpUtil.h>

#include <e32math.h>

#include <bsp.h>

#include "videoserviceutilsLogger.h"

// CONSTANTS

const TInt KMaxGroupTime( 4000 ); // 4s

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

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

// CRtpClipRepairer::NewL

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

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

//

CRtpClipRepairer* CRtpClipRepairer::NewL( MRtpClipRepairObserver* aObs )

    {

    CRtpClipRepairer* self = new( ELeave ) CRtpClipRepairer( aObs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CRtpClipRepairer::CRtpClipRepairer

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

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

//

CRtpClipRepairer::CRtpClipRepairer( MRtpClipRepairObserver* aObs )

  : CRtpFileBase(),

    iObs( aObs ),

    iSeekArrayPoint( KErrNotFound )

    {

    // None

    }

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

// CRtpClipRepairer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRtpClipRepairer::ConstructL()

    {

    LOG( "CRtpClipRepairer::ConstructL()" );

    CRtpFileBase::ConstructL();

    }

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

// Destructor

//

CRtpClipRepairer::~CRtpClipRepairer()

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

    {

    LOG( "CRtpClipRepairer::~CRtpClipRepairer()" );

    Cancel();

    delete iFileData;

    delete iMetaHeader;

    }

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

// CRtpClipRepairer::CurrentClipName

// Getter for the clip name under repairing.

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

//

TPtrC CRtpClipRepairer::CurrentClipName()

    {

    if ( iCurrentPath )

        {

        return iCurrentPath->Des();

        }

    return KNullDesC();

    }

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

// CRtpClipRepairer::CheckMetaHeaderL

// Checks if corrupted meta header of clip is possible to fix.

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

//

void CRtpClipRepairer::CheckMetaHeaderL( const TDesC& aClipName )

    {

    LOG1( "CRtpClipRepairer::CheckMetaHeaderL(), aClipName: %S", &aClipName );

    // Only one repair at the time

    if ( iMetaHeader || iCurrentPath )

        {

        User::Leave( KErrAlreadyExists );

        }

    // Open clip and read the meta header

    delete iCurrentPath; iCurrentPath = NULL;

    iCurrentPath = aClipName.AllocL();

    if ( !iFs.Handle() )

        {

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

        }

    iFile.Close();

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

                        EFileShareExclusive | EFileStream | EFileWrite ) );

    delete iMetaHeader; iMetaHeader = NULL;

    iMetaHeader = CRtpMetaHeader::NewL( iFile, CRtpMetaHeader::EMetaUpdate );

    // Attributes

    CRtpMetaHeader::SAttributes att;

    TRAPD( err, iMetaHeader->ReadAttributesL( att ) );

    // Verify that clip version not too old?

    if ( att.iVersion < KMinValidClipVersion )

        {

        LOG( "CRtpClipRepairer::CheckMetaHeaderL(), Not Valid Clip Version" );

        User::Leave( KErrGeneral ); 

        }

    // If error or rec ongoing -> recording interrupted ie. battery removed

    if ( err || att.iOngoing )

        {

        att.iOngoing = EFalse;

        att.iPlayCount = 0;

        att.iPlaySpot = KErrNone;

        iMetaHeader->WriteAttributesL( att );

        }

    // Duration

    TInt duration( 0 );

    iMetaHeader->ReadDurationL( duration );

    LOG1( "CRtpClipRepairer::CheckMetaHeaderL(), duration: %d", duration );

    // Update seek array

    if ( ( !duration || duration > KSeekArrayInterval ) && !ValidSeekHeaderL() )

        {

        UpdateSeekArrayL();

        }

    else

        {

        // Set start time to file date

        TTime startTime( 0 );

        iMetaHeader->ReadStartTimeL( startTime );

        iFile.SetModified( startTime );

        iFile.Close();

        }

    }

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

// CRtpClipRepairer::RunL

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

//

void CRtpClipRepairer::RunL()

    {

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

    const TUint prevTime( iGroupTime );

    UpdateGroupHeaderVariablesL( iDataPtr );

    delete iFileData; iFileData = NULL;

    // Current header valid?

    if ( iThisGroup > iNextGroupPoint || iThisGroup < iPrevGroupPoint ||

         iGroupTime < prevTime || iGroupTime > ( prevTime + KMaxGroupTime ) )

        {

        iLastSeekAddr = iPrevGroupPoint;

        iThisGroup = iSeekArrayPoint;

        }

    else

        {

        // Handle readed group

        GroupToSeekArrayL();

        }

    // Continue with next group if repair asyncronous?

    if ( iObs )

        {

        if ( iThisGroup < iSeekArrayPoint )

            {

            // Asyncronous ( normal clip repairing )

            ReadNextGroupHeaderFromFileL();

            }

        else

            {

            // All done, finalize the clip

            AddSpecialPacketL( MRtpFileWriteObserver::ERtpClipEnd );

            FinalizeSeekArrayL( KErrNone );

            iObs->RtpClipRepaired( KErrNone );

            }        

        }

    }

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

// CRtpClipRepairer::RunError

// Returns: System wide error code of indication send leave reason

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

//

TInt CRtpClipRepairer::RunError( TInt aError )

    {

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

    TRAP_IGNORE( FinalizeSeekArrayL( aError ) );

    if ( iObs )

        {

        iObs->RtpClipRepaired( ( iGroupsTotalCount )? KErrNone: aError );

        }

    return KErrNone;

    }

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

// CRtpClipRepairer::DoCancel

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

//

void CRtpClipRepairer::DoCancel()

    {

    LOG( "CRtpClipRepairer::DoCancel()" );

    }

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

// CRtpClipRepairer::ValidSeekHeaderL

// Verifies if seek header and seek array are valid.

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

//

TBool CRtpClipRepairer::ValidSeekHeaderL()

    {

    // Seek header

    iSeekHeaderPoint = iMetaHeader->SeekHeaderPoint();

    ReadSeekHeaderL();

    // Seek array point

    iMetaHeader->ReadSeekArrayPointL( iSeekArrayPoint );

    // Verify seek array

    if ( iLastSeekAddr > iFirstSeekAddr && iSeekArrayPoint > iLastSeekAddr )

        {

        TInt count( KErrNotFound );

        TRAPD( err, count = ReadSeekArrayL( iSeekArrayPoint ) );

        if ( !err && count > 0 )

            {

            // Seek array is ok

            return ETrue; 

            }

        }

    return EFalse;

    }

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

// CRtpClipRepairer::UpdateSeekArrayL

// Scans all packet groups in clip and updates seek array.

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

//

void CRtpClipRepairer::UpdateSeekArrayL()

    {

    LOG( "CRtpClipRepairer::UpdateSeekArrayL()" );

    // Scan complete clip for seek array

    ResetSeekArray();

    User::LeaveIfError( iFile.Size( iSeekArrayPoint ) );

    iThisGroup = iFirstSeekAddr;

    iGroupTime = 0;

    iNextGroupPoint = 0;

    iGroupsTotalCount = 0;

    // Start reading

    if ( iObs )

        {

        // Asyncronous

        ReadNextGroupHeaderFromFileL();

        }

    else

        {

        // Syncronous

        TInt err( KErrNone );

        do

            {

            ReadNextGroupHeaderFromFileL();

            TRAP( err, RunL() );

            }

            while ( !err && iThisGroup < iSeekArrayPoint );

        // All done, finalize the clip

        AddSpecialPacketL( MRtpFileWriteObserver::ERtpClipPause );

        FinalizeSeekArrayL( KErrNone );

        }

    }

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

// CRtpClipRepairer::ReadNextGroupHeaderFromFileL

// Reads RTP payload from a file.

// Payload is allways after data header, so read position set is not needed.

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

//

void CRtpClipRepairer::ReadNextGroupHeaderFromFileL()

    {

    iLastSeekAddr = iThisGroup;

    iFileData = HBufC8::NewL( KGroupHeaderBytes );

    iDataPtr.Set( iFileData->Des() );

    if ( iObs )

        {

        iFile.Read( iThisGroup, iDataPtr, KGroupHeaderBytes, iStatus );

        SetActive();

        }

    else

        {

        iStatus = iFile.Read( iThisGroup, iDataPtr, KGroupHeaderBytes );

        }

    }

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

// CRtpClipRepairer::GroupToSeekArrayL

// Appends next rec group's group time to seek array if interval time exeeded.

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

//

void CRtpClipRepairer::GroupToSeekArrayL()

    {

    iGroupsTotalCount++;

    const TInt delta( iGroupTime - iLastGroupTime );

    if ( delta > KSeekArrayInterval )

        {

        LOG2( "CRtpClipRepairer::GroupToSeekArrayL(), iGroupsTotalCount: %d, iThisGroup: %d", 

                                                      iGroupsTotalCount, iThisGroup );

        iLastGroupTime = iGroupTime;

        AppendSeekArrayL( iGroupTime, iThisGroup );

        }

    iPrevGroupPoint = iThisGroup;

    iThisGroup = iNextGroupPoint;

    }

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

// CRtpClipRepairer::AddSpecialPacketL

// Adds special packet to a new group to the end of clip.

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

//

void CRtpClipRepairer::AddSpecialPacketL( 

    const MRtpFileWriteObserver::TRtpType aType )

    {

    LOG1( "CRtpClipRepairer::AddSpecialPacketL(), aType: %d", aType );

    // Read last group header

    iThisGroup = iPrevGroupPoint;

    ReadGroupHeaderL();

    // End packet

    HBufC8* bytes = CRtpUtil::SpecialPacketL( aType );

    CleanupStack::PushL( bytes );

    iFile.Write( iThisGroup + iGroupTotalLen, bytes->Des(), KSpecialPacketLength );

    CleanupStack::PopAndDestroy( bytes );

    // Update group total size (GTS)

    iGroupTotalLen+= KSpecialPacketLength;

    bytes = CRtpUtil::MakeBytesLC( iGroupTotalLen );

    iFile.Write( iThisGroup, bytes->Des(), KIntegerBytes );

    CleanupStack::PopAndDestroy( bytes );

    // Update next group point (NGP)

    iNextGroupPoint+= KSpecialPacketLength;

    bytes = CRtpUtil::MakeBytesLC( iNextGroupPoint );

    iFile.Write( iThisGroup + KIntegerBytes, bytes->Des(), KIntegerBytes );

    CleanupStack::PopAndDestroy( bytes );

    // Read packets total count (PTC)

    bytes = HBufC8::NewLC( KPacketsCountBytes );

    TPtr8 ptr( bytes->Des() );

    iFile.Read( iThisGroup + KGroupHeaderBytes, ptr, KPacketsCountBytes );

    const TInt packetsCount( CRtpUtil::GetValueL( ptr ) );

    User::LeaveIfError( packetsCount );

    CleanupStack::PopAndDestroy( bytes );

    // Increment packets tolal count (PTC) by one

    bytes = CRtpUtil::MakeBytesLC( packetsCount + 1 );

    iFile.Write( iThisGroup + KGroupHeaderBytes, bytes->Des(), KPacketsCountBytes );

    CleanupStack::PopAndDestroy( bytes );

    }

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

// CRtpClipRepairer::FinalizeSeekArrayL

// Appends next rec group to seek array.

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

//

void CRtpClipRepairer::FinalizeSeekArrayL( const TInt aError )

    {

    LOG1( "CRtpClipRepairer::FinalizeSeekArrayL(), aError: %d", aError );

    // New seek array point

    iMetaHeader->WriteSeekArrayPointL( iNextGroupPoint );

    // Update duration

    iMetaHeader->WriteDurationL( iGroupTime );

    // Last group time

    CRtpMetaHeader::SAttributes att;

    iMetaHeader->ReadAttributesL( att );

    att.iFailed = !( !aError );

    att.iOngoing = EFalse;

    att.iPlayCount = 0;

    att.iPlaySpot = KErrNone;

    iMetaHeader->WriteAttributesL( att );

    // Finalise

    SaveSeekArrayL();

    WriteSeekHeaderL();

    iFile.Flush();

    // Set start time to file date

    TTime startTime( 0 );

    iMetaHeader->ReadStartTimeL( startTime );

    iFile.SetModified( startTime );

    iFile.Close();

    }

// End of File