/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:    

*

*/

// INCLUDE FILES

#include "mccqoscontroller.h"

#include "mccrateadaptationobserver.h"

#include "mmccevents.h"

#include "mccresources.h"

#include "mccdatasource.h"

#include "mccdatasink.h"

#include "QosControllerLog.h"

#include "mccinternalevents.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TInt KPluginMicroSecInSec = 1;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CMccQosController::NewL

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

//

EXPORT_C CMccQosController* CMccQosController::NewL( 

    MMccRateAdaptationObserver& aObserver,

    MMccResources& aResources )

    {

    __TRACE_MCC_QOS_CONTROLLER1("CMccQosController::NewL");

    CMccQosController* self = 

        new ( ELeave ) CMccQosController( aObserver, aResources );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccQosController::~CMccQosController

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

//        

EXPORT_C CMccQosController::~CMccQosController()

    {

    __TRACE_MCC_QOS_CONTROLLER1("CMccQosController::~CMccQosController");

    if ( iDeltaTimer )

        {

        iDeltaTimer->Remove( iDeltaTimerEntry );

        }

    delete iDeltaTimer;

    iIcmpErrors.Reset();

    iIcmpErrors.Close();

    __TRACE_MCC_QOS_CONTROLLER1("CMccQosController::~CMccQosController end");

    }

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

// CMccQosController::EventReceived

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

//

EXPORT_C TBool CMccQosController::EventReceived( const TMccEvent& aEvent )

    {

    __TRACE_MCC_QOS_CONTROLLER1("CMccQosController::EventReceived");

    // Check if interesting event and then do calculations.

    // If adaptation is needed, make async brake and continue with it once

    // dummy async completes. QosController has also responsibility of

    // icmp error handling (random errors are filtered etc.).

    TBool ignoreEvent( EFalse );

    if ( aEvent.iEventCategory == KMccEventCategoryRtcp )

    	{

		__TRACE_MCC_QOS_CONTROLLER3(

		    "CMccQosController::EventReceived TMccEvent:iSessionId=", 

		    aEvent.iSessionId);

		__TRACE_MCC_QOS_CONTROLLER3(

		    "CMccQosController::EventReceived TMccEvent:iLinkId=", 

		    aEvent.iLinkId);

		__TRACE_MCC_QOS_CONTROLLER3(

		    "CMccQosController::EventReceived TMccEvent:iStreamId=", 

		    aEvent.iStreamId);

		__TRACE_MCC_QOS_CONTROLLER3(

		    "CMccQosController::EventReceived TMccEvent:iEndpointId=", 

		    aEvent.iEndpointId);

		__TRACE_MCC_QOS_CONTROLLER3(

		    "CMccQosController::EventReceived TMccEvent:iErrorCode=", 

		    aEvent.iErrorCode);

		const TMccRtcpEventData& eventdata = 

    		(*reinterpret_cast<const TMccRtcpEventDataPackage*>( 

                &aEvent.iEventData ))(); 

    	if ( eventdata.iRtcpPacketType == KRtcpRrPacket )

            {

            // RR received

            iStreamStat = eventdata.iStats;

			__TRACE_MCC_QOS_CONTROLLER3(

			    "CMccQosController::EventReceived TRtpPeerStat:iNumPacketsSent=", 

			    iStreamStat.iNumPacketsSent);

			__TRACE_MCC_QOS_CONTROLLER3(

			    "CMccQosController::EventReceived TRtpPeerStat:iCumNumOctetsSent=", 

			    iStreamStat.iCumNumOctetsSent);

			__TRACE_MCC_QOS_CONTROLLER3(

			    "CMccQosController::EventReceived TRtpPeerStat:RoundTripDelay=", 

			    iStreamStat.iRoundTripDelay);

  			__TRACE_MCC_QOS_CONTROLLER3(

  			    "CMccQosController::EventReceived TRtpPeerStat:iTxBandwidth=", 

  			    iStreamStat.iTxBandwidth);

 			__TRACE_MCC_QOS_CONTROLLER3(

 			    "CMccQosController::EventReceived TRtpPeerStat:iCumNumPacketsLost=", 

 			    iStreamStat.iCumNumPacketsLost);

 			__TRACE_MCC_QOS_CONTROLLER3(

 			    "CMccQosController::EventReceived TRtpPeerStat:iFractionLost=", 

 			    iStreamStat.iFractionLost);

 			__TRACE_MCC_QOS_CONTROLLER3(

 			    "CMccQosController::EventReceived TRtpPeerStat:iArrivalJitter=", 

 			    iStreamStat.iArrivalJitter);

  			__TRACE_MCC_QOS_CONTROLLER3(

  			    "CMccQosController::EventReceived TRtpPeerStat:iRxBandwidth=", 

  			    iStreamStat.iRxBandwidth);

   			__TRACE_MCC_QOS_CONTROLLER3(

   			    "CMccQosController::EventReceived TRtpPeerStat:iChannelBufferSize=", 

   			    iStreamStat.iChannelBufferSize);

  			__TRACE_MCC_QOS_CONTROLLER3(

  			    "CMccQosController::EventReceived TRtpPeerStat:iNTPTimeStampSec=", 

  			    iStreamStat.iNTPTimeStampSec);   			

  			__TRACE_MCC_QOS_CONTROLLER3(

  			    "CMccQosController::EventReceived TRtpPeerStat:iNTPTimeStampFrac=", 

  			    iStreamStat.iNTPTimeStampFrac);

            DoAdaptationCalculations();

            }

        }

    else if ( aEvent.iEventCategory == KMccEventCategoryRtp && 

              aEvent.iEventType == KMccStreamError &&

              aEvent.iErrorCode == KErrHostUnreach )

        {

        ignoreEvent = HandleIcmpError( aEvent );

        }

    else

        {

        // NOP

        }

    __TRACE_MCC_QOS_CONTROLLER1("CMccQosController::EventReceived end");   

    return ignoreEvent;

    }

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

// CMccQosController::DoAdaptationCalculations  

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

//  

void CMccQosController::DoAdaptationCalculations()

	{

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::DoAdaptationCalculations");

	#ifdef RATECONTROL

	ClearRateEventData();

	__TRACE_MCC_QOS_CONTROLLER3("CMccQosController::RoundTripTime", 

	                            iRoundTripTime );

	__TRACE_MCC_QOS_CONTROLLER3("CMccQosController::RoundTripDelay", 

	                            iStreamStat.iRoundTripDelay );

	if ( iRoundTripTime )

		{

		// Temporary change will not affect immediately so much (kind of mean value)

		const TReal q = 0.9;

		iRoundTripTime = 

		    TInt ( q * iRoundTripTime + (1.0 - q) * iStreamStat.iRoundTripDelay );

		__TRACE_MCC_QOS_CONTROLLER3("CMccQosController::New RoundTripTime=", 

		                            iRoundTripTime );

		}

	else

		{

		iRoundTripTime = iStreamStat.iRoundTripDelay; 

		}

	// Store some amount of previous round trip delay values in order to

	// calculate average value of certain period	

    iRoundTripDelays[ iEventCounter % KMccShortTermCalculation ] = iStreamStat.iRoundTripDelay;

    iEventCounter++;

    TBool adaptedAtThisRound( EFalse );

	if ( iStreamStat.iFractionLost > iThresholdValues.iFractionLostHigh )

	    {

	    // Immediately drop bitrate if significant number of packets got lost

	    __TRACE_MCC_QOS_CONTROLLER1(

	        "CMccQosController::DoAdaptationCalculations, fractions lost, decrease");

	    iRateEventData.iRateAdaptationAdvice = ( 1.0 - KAdaptation );

	    DoAdaptation();

	    adaptedAtThisRound = ETrue;

	    }	 

    if ( !( iEventCounter % KMccShortTermCalculation ) )

        {

        // If long term calculation resulted in change, we are interested 

        // how it affected to average round trip delay

        __TRACE_MCC_QOS_CONTROLLER1(

            "CMccQosController::DoAdaptationCalculations, short term");

        TInt roundTripDelayOfThisPeriod = CalculateDelayOfShortTermPeriod();

        __TRACE_MCC_QOS_CONTROLLER3(

            "CMccQosController::DoAdaptationCalculations, avg delay of this period", 

            roundTripDelayOfThisPeriod );

        if ( !adaptedAtThisRound )

            {

            TInt comparisonDelay = GetShortTermComparisonDelay();

            __TRACE_MCC_QOS_CONTROLLER3(

                "CMccQosController::DoAdaptationCalculations, comparison delay", 

                comparisonDelay );

            if ( roundTripDelayOfThisPeriod - comparisonDelay > KRoundTripTimeLimit )

                {

                __TRACE_MCC_QOS_CONTROLLER1(

                    "CMccQosController::DoAdaptationCalculations, decrease");

                iRateEventData.iRateAdaptationAdvice = 1.0 - KAdaptation;

                DoAdaptation();

                adaptedAtThisRound = ETrue;

                }

            else if ( comparisonDelay - roundTripDelayOfThisPeriod > KRoundTripTimeLimit )

                {

                __TRACE_MCC_QOS_CONTROLLER1(

                    "CMccQosController::DoAdaptationCalculations, increase");

                iRateEventData.iRateAdaptationAdvice = 1.0 + KAdaptation;

                DoAdaptation();

                adaptedAtThisRound = ETrue;

                }

            else

                {

                }

            }

        iRoundTripDelayOfPreviousShortPeriod = roundTripDelayOfThisPeriod;

        }

	if ( !( iEventCounter % KMccLongTermCalculation ) )

	    {

	    __TRACE_MCC_QOS_CONTROLLER1(

	        "CMccQosController::DoAdaptationCalculations, long term");

	    if ( !adaptedAtThisRound && !iAdapted )

	        {

	        // If adaptation wasn't needed within previous long term period, try to

	        // increase bitrate. Remember round trip time of this period so that

	        // we can see what kind of impact the increasing of bitrate has. 

	        __TRACE_MCC_QOS_CONTROLLER1(

	            "CMccQosController::DoAdaptationCalculations, try to increase");

	        iRateEventData.iRateAdaptationAdvice = ( 1.0 + KAdaptationMore );

	        DoAdaptation();

	        adaptedAtThisRound = ETrue;

	        }

	    iAdapted = EFalse;

	    }

	#endif //RATECONTROL	

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::DoAdaptationCalculations end");

    }

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

// CMccQosController::FillRateAdaptationEventL

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

//      

void CMccQosController::FillRateAdaptationEvent()

	{

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::FillRateAdaptationEvent");

	iEvent = TMccEvent();

	TMccRateAdaptationEventDataPackage temp(iRateEventData);

	iEvent.iEventData.Copy( temp );	 

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::FillRateAdaptationEvent end");

	}

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

// CMccQosController::ClearRateEventData

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

//      

void CMccQosController::ClearRateEventData()

	{

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::ClearRateEventData");	

	iRateEventData = TMccRateAdaptationEventData();

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::ClearRateEventData end");	

	}

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

// CMccQosController::StartTimerForAsync

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

//

void CMccQosController::StartTimerForAsync ()

	{

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::StartTimerForAsync");

	iDeltaTimer->Remove(iDeltaTimerEntry);

	TTimeIntervalMicroSeconds32 interval(KPluginMicroSecInSec);

	iDeltaTimer->Queue(interval, iDeltaTimerEntry);

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::StartTimerForAsync end");	

	}	

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

// CMccQosController::AsyncTimerExpired

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

//

TInt CMccQosController::AsyncTimerExpired(TAny* aPtr)

	{

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::AsyncTimerExpired");

	CMccQosController* self = reinterpret_cast<CMccQosController*>(aPtr);

	self ->GetSinkSources();

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::AsyncTimerExpired end");

  	return ETrue;

	} 

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

// CMccQosController::GetSinkSources

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

//

void CMccQosController::GetSinkSources()

	{

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::GetSinkSources");

    iBitRateChanged = EFalse;

    const RPointerArray<MDataSource>& tempSources = iResources.Sources( ETrue );

  	FillRateAdaptationEvent();

  	TInt result = 0;

  	for ( TInt i = 0; i < tempSources.Count(); i++ )

        {

        iResultEvent = TMccEvent();

		__TRACE_MCC_QOS_CONTROLLER3("CMccQosController::GetSinkSources Sources", i);

        CMccDataSource* item = static_cast<CMccDataSource*> (tempSources[ i ]); 

        iResultEvent = TMccEvent(); 	

        result = item->RateAdaptationRequest( iEvent, iResultEvent );

        CheckRateChangeResult( result );

        }

  	const RPointerArray<MDataSink>& tempSinks = iResources.Sinks( ETrue );

  	for ( TInt j = 0; j < tempSinks.Count(); j++ )

        {

        iResultEvent = TMccEvent();

		__TRACE_MCC_QOS_CONTROLLER3("CMccQosController::GetSinkSources Sinks", j);        

        CMccDataSink* item = static_cast<CMccDataSink*> (tempSinks[ j ]);

        result = item->RateAdaptationRequest( iEvent, iResultEvent );

        CheckRateChangeResult( result );

        }

    if ( !iBitRateChanged )

    	{

    	iMainObserver.RateAdaptationAlert( iEvent,

    				 MMccRateAdaptationObserver::ERateAdaptationNotPossible );

    	}

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::GetSinkSources END"); 

	}    

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

// CMccQosController::CheckRateChangeResult

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

// 

void CMccQosController::CheckRateChangeResult( TInt aValue )

    {

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::CheckRateChangeResult");    

    if ( aValue == KErrNone )

    	{

		TMccRateAdaptationEventDataPackage resultdatapkg;

		resultdatapkg.Copy(iResultEvent.iEventData);

		TMccRateAdaptationEventData resultdata = resultdatapkg();

        if ( resultdata.iBitrateOriginal != resultdata.iBitrateModified )

        	{

        	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::BitRateChanged ETRUE");

        	iBitRateChanged = ETrue;

        	}

    	}

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::CheckRateChangeResult end");

    }

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

// CMccQosController::HandleIcmpError

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

// 

TBool CMccQosController::HandleIcmpError( const TMccEvent& aEvent )

    {

    __TRACE_MCC_QOS_CONTROLLER1("CMccQosController::HandleIcmpError");   

    // By default error is ignored. Only if there has been certain amount

    // of errors within certain time window, error is reported.

    //

    TBool ignoreError( ETrue );

    // Do first cleanup of all entries which have exceeded their monitoring

    // timewindow.

    TTime currentTime;

    currentTime.HomeTime();

    TMccQosControllerIcmpError cleanupIcmpError;

    cleanupIcmpError.iErrorTimeWindowBeginning = currentTime;

    TIdentityRelation<TMccQosControllerIcmpError> 

        cleanupComparison( IcmpErrorCleanup );

    TInt index = iIcmpErrors.Find( cleanupIcmpError, cleanupComparison );

    while ( index != KErrNotFound )

        {

        iIcmpErrors.Remove( index );

        index = iIcmpErrors.Find( cleanupIcmpError, cleanupComparison );

        }

    __TRACE_MCC_QOS_CONTROLLER1("CMccQosController::HandleIcmpError, cleanup done");  

    TIdentityRelation<TMccQosControllerIcmpError> comparison( IcmpErrorMatch );

    TMccQosControllerIcmpError icmpError;

    icmpError.iLinkId = aEvent.iLinkId;

    index = iIcmpErrors.Find( icmpError, comparison );

    if ( index != KErrNotFound )

        {

        TMccQosControllerIcmpError& existingIcmpError = iIcmpErrors[ index ];

        existingIcmpError.iErrorCount++;

        if ( existingIcmpError.iErrorCount >= KMccIcmpErrorThreshold )

            {

            // Report the error

            ignoreError = EFalse;

            iIcmpErrors.Remove( index );

            }

        }

    else

        {

        icmpError.iErrorCount = KMccFirstIcmpError;

        icmpError.iErrorTimeWindowBeginning = currentTime;

        // It does not matter if entry cannot be added because of low memory

        iIcmpErrors.Append( icmpError );

        }

    __TRACE_MCC_QOS_CONTROLLER3("CMccQosController::HandleIcmpError ignore:", 

                                ignoreError );  

    return ignoreError;

    }

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

// CMccQosController::IcmpErrorMatch

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

//     

TBool CMccQosController::IcmpErrorMatch( 

    const TMccQosControllerIcmpError& aError1, 

    const TMccQosControllerIcmpError& aError2 )

    {

    // First argument is the search term

    return ( aError1.iLinkId == aError2.iLinkId );

    }

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

// CMccQosController::IcmpErrorCleanup

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

//     

TBool CMccQosController::IcmpErrorCleanup( 

    const TMccQosControllerIcmpError& aError1, 

    const TMccQosControllerIcmpError& aError2 )

    {

    // First argument is the search term

    TInt64 timeWindow = 

        aError1.iErrorTimeWindowBeginning.MicroSecondsFrom( 

            aError2.iErrorTimeWindowBeginning ).Int64();

    return ( timeWindow > KMccIcmpErrorTimeWindow );

    }

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

// CMccQosController::CMccQosController

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

//      

CMccQosController::CMccQosController(

    MMccRateAdaptationObserver& aObserver,

    MMccResources& aResources ) :

    iMainObserver( aObserver ),

    iResources( aResources ),

    iDeltaTimerCallBack(AsyncTimerExpired, this),

    iBitRateChanged(EFalse)

    {

    __TRACE_MCC_QOS_CONTROLLER1("CMccQosController::CMccQosController");

    iDeltaTimerEntry.Set(iDeltaTimerCallBack);

    }

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

// CMccQosController::ConstructL

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

// 

void CMccQosController::ConstructL()

    {

	__TRACE_MCC_QOS_CONTROLLER1("CMccQosController::ConstructL");    

    iDeltaTimer = CDeltaTimer::NewL(CActive::EPriorityStandard);

    iEventCounter = 0;

    #ifdef RATECONTROL

    //rate control threshold values

    iThresholdValues.iFractionLostHigh = 30;

    iThresholdValues.iFractionLostLow = 0;

	iRoundTripTime = 0;