/*

* 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 to provide TS conversion for an RTP-stream based on*

*/

// INCLUDE FILES

#include "CRtpTsConverter.h"

#include <ipvideo/CRtpUtil.h>

#include "videoserviceutilsLogger.h"

// CONSTANTS

const TInt KValidRtcpType( 200 );

const TInt KTypeBytesPoint( 1 );

const TInt KNtpSecBytesPoint( 8 );

const TInt KNtpFracBytesPoint( 12 );

const TInt KRtcpTsBytesPoint( 16 );

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

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

// CRtpTsConverter::NewL

// Two-phased constructor.

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

//

EXPORT_C CRtpTsConverter* CRtpTsConverter::NewL( const TUint aClockRate )

    {

    CRtpTsConverter* self = new( ELeave ) CRtpTsConverter( aClockRate );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CRtpTsConverter::CRtpTsConverter

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

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

//

CRtpTsConverter::CRtpTsConverter( const TUint aClockRate )

  : iClockRate( aClockRate ),

    iOffset( 0 ),

    iInitiated( EFalse )

    {

    // None

    }

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

// CRtpTsConverter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRtpTsConverter::ConstructL()

    {

    // None

    }

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

// CRtpTsConverter::CRtpTsConverter

// Destructor.

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

//

EXPORT_C CRtpTsConverter::~CRtpTsConverter()

    {

    // None

    }

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

// CRtpTsConverter::Init

// 

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

//

EXPORT_C void CRtpTsConverter::Init( const TDesC8& aRtcpPkt )

    {

    // Verify packet type?

    if ( aRtcpPkt.Length() > ( KRtcpTsBytesPoint + KIntegerBytes ) && 

         aRtcpPkt[KTypeBytesPoint] == KValidRtcpType && iClockRate > 0 )

        {

        // Handle RTCP packet

        TUint ntp_sec( 0 );

        TUint ntp_frac( 0 );

        TUint rtcp_ts( 0 );

        TInt err( CRtpUtil::GetValue( 

             aRtcpPkt.Mid( KNtpSecBytesPoint, KIntegerBytes ), ntp_sec ) );

        if ( !err )

            {

            LOG1( "CRtpTsConverter::Init(), NTP Timestamp, MSW: %u", ntp_sec );

            err = CRtpUtil::GetValue( 

                  aRtcpPkt.Mid( KNtpFracBytesPoint, KIntegerBytes ), ntp_frac );

            }

        if ( !err )

            {

            LOG1( "CRtpTsConverter::Init(), NTP Timestamp, LSW: %u", ntp_frac );

            err = CRtpUtil::GetValue( 

                  aRtcpPkt.Mid( KRtcpTsBytesPoint, KIntegerBytes ), rtcp_ts );

            }

        if ( !err )

            {

            LOG1( "CRtpTsConverter::Init(), RTP Timestamp: %u", rtcp_ts );

            // Calculate the wallclock time when this RTCP packet is generated

            TUint wallClock( ( ntp_sec & 0x00FF ) * 1000 );

            wallClock += ( ( ( ntp_frac >> 16 ) & 0x0000FFFF ) * 1000 ) >> 16;

            // Compute the proper time offset

            iOffset = ComputeOffset( rtcp_ts, wallClock, iClockRate );

            }

        }

    }

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

// CRtpTsConverter::Init

// Compute the proper time offset. No wallclok time available.

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

//

EXPORT_C void CRtpTsConverter::Init( const TUint& aTs )

    {

    iOffset = ComputeOffset( aTs, 0, iClockRate );

    }

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

// CRtpTsConverter::Initiated

// Returns: initiated status of converter.

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

//

EXPORT_C TBool CRtpTsConverter::Initiated()

    {

    return iInitiated;

    }

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

// CRtpTsConverter::UnInitiate

//

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

//

EXPORT_C void CRtpTsConverter::UnInitiate()

    {

    iInitiated = EFalse;

    }

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

// CRtpTsConverter::ConvertTs

// Returns: converted unsigned integer value of timestamp.

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

//

EXPORT_C TUint CRtpTsConverter::ConvertTs( 

    const TUint aTimestamp,

    TBool aUseWallClock )

    {

    TUint ret( KMaxTUint );

    if ( iClockRate == KPipelineClockRate )

        {

        ret = aTimestamp - iOffset;

        }

    else

        {

        if ( iClockRate > 0 )

            {

            ret = aTimestamp - iOffset;

            if ( aUseWallClock )

                {

                TUint sec( ret / iClockRate );

                TUint subSec( ret % iClockRate );

                ret = ( ( sec * KPipelineClockRate ) + 

                        ( subSec * KPipelineClockRate ) / iClockRate );

                }

            }

        }

    return ret;

    }

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

// CRtpTsConverter::ComputeOffset

// Returns: offset of the RTP timestamp.

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

//

TUint CRtpTsConverter::ComputeOffset(

    TUint aRtpTime,

    TUint aSeekTime,

    TInt aClockRate )

    {

    TUint ret( KMaxTUint );

    if ( aClockRate )

        {

        TUint rtpSec( aRtpTime / aClockRate );

        TUint rtpFracSecTU( aRtpTime % aClockRate ); // transport units

        TUint seekSec( aSeekTime / 1000 );

        TUint seekFracSecTU( ( ( aSeekTime % 1000) * aClockRate ) / 1000 );

        TUint offsetSec( rtpSec - seekSec );

        TUint offsetFracSecTU( rtpFracSecTU - seekFracSecTU );

        if ( rtpFracSecTU < seekFracSecTU )

            {

            offsetSec--;

            offsetFracSecTU = aClockRate + rtpFracSecTU - seekFracSecTU;

            }

        ret = ( offsetSec * aClockRate ) + offsetFracSecTU;

        iInitiated = ETrue;

        }

    return ret;

    }

// End of File