/*

* Copyright (c) 2008-2009 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:

*

*/

// NOTE: Assumes OMX_SKIP64BIT is not set when building OMX CORE

#include <hal.h>

#include <openmax/il/khronos/v1_x/OMX_Other.h>	// OMX port

#include "omxilspecversion.h"	// OMX version number

#include "clocksupervisor.h"

#include "comxilclockprocessingfunction.h"

#include "clockpanics.h"

#include "omxilclock.hrh"

#include "log.h"

//////////////

// File scoped constants

//

/** The maximum number of simultaneous outstanding requests (across all ports) */

static const TUint KMaxRequests = 20;

static const TUint KThreadStackSize = 1024;

/**

 * Assumption that timer will always take at least this long to complete.

 * How soon an outstanding delay must be before we complete immediately instead of setting a timer.

 */

static const TInt KMinTimerOverhead = 1000;	// 1000usecs = 1ms

// assumption that timers go off at some time rounded to this many microseconds

static const TInt KTimerQuantization = 

#ifdef __WINSCW__

	15000;

#else

	1;

#endif

// aim to select a counter accurate to ~1ms

#ifdef __WINSCW__

#define USE_FASTCOUNTER // typically faster than 1ms on emulator, 1ms on hardware

#else

#define USE_NTICKCOUNT	// typically 5ms on emulator, 1ms on hardware

#endif

#if !defined(USE_FASTCOUNTER) && !defined(USE_NTICKCOUNT)

#error Either USE_FASTCOUNTER or USE_NTICKCOUNT must be defined

#endif

/**

 * Structure to map OMX_INDEXTYPE to behaviour required by the Clock component.

 */

// Indexes for time configs start after OMX_IndexTimeStartUnused = 0x09000000

// Simply deduct this to index this table

static const OMX_INDEXTYPE KMinJumpTableIndex = OMX_IndexConfigTimeScale;

static const OMX_INDEXTYPE KMaxJumpTableIndex = OMX_IndexConfigTimeClientStartTime;

const CClockSupervisor::FunctionPtr CClockSupervisor::iJumpTable[] = 

	{

	/*OMX_IndexConfigTimeScale*/					&CClockSupervisor::HandleGetSetTimeScale	     ,// requires buffers

	/*OMX_IndexConfigTimeClockState*/				&CClockSupervisor::HandleGetSetClockState	     ,// requires buffers

	/*OMX_IndexConfigTimeActiveRefClock*/			&CClockSupervisor::HandleGetSetActiveRefClock  ,

	/*OMX_IndexConfigTimeCurrentMediaTime*/			&CClockSupervisor::HandleQueryCurrentMediaTime ,

	/*OMX_IndexConfigTimeCurrentWallTime*/			&CClockSupervisor::HandleQueryCurrentWallTime	 ,

	/*OMX_IndexConfigTimeCurrentAudioReference*/	&CClockSupervisor::HandleUpdateAudioReference	 ,

	/*OMX_IndexConfigTimeCurrentVideoReference*/	&CClockSupervisor::HandleUpdateVideoReference	 ,

	/*OMX_IndexConfigTimeMediaTimeRequest*/			&CClockSupervisor::HandleSubmitMediaTimeRequest,// requires buffers

	/*OMX_IndexConfigTimeClientStartTime*/			&CClockSupervisor::HandleSetPortClientStartTime,

	};

#ifdef _DEBUG

#define CHECK_DEBUG()	DbgCheck()

#else

#define CHECK_DEBUG()

#endif

//////////////

/**

 * Euclid's algorithm.

 * Returns the largest common factor of aX and aY.

 */

static TInt LargestCommonFactor(TInt aX, TInt aY)

	{

	// based on knowledge that lcf(x,0)=x, lcf(x,y)=lcf(y,x) and lcf(x,y)=lcf(y,x%y)

	while(aX != 0)

		{

		aY %= aX;

		if(aY == 0)

			{

			return aX;

			}

		aX %= aY;

		}

	return aY;

	}

/**

 *

 *

 */

CClockSupervisor* CClockSupervisor::NewL(COmxILClockProcessingFunction& aProcessingFunction)

	{

	CClockSupervisor* self = new (ELeave) CClockSupervisor(aProcessingFunction);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 *

 *

 */

void CClockSupervisor::ConstructL()

	{

	// calculate tick frequency

	//

#ifdef USE_FASTCOUNTER

	TInt frequency;	// tick frequency in Hz

	User::LeaveIfError(HAL::Get(HAL::EFastCounterFrequency, frequency));

	// conversion factor from ticks into microseconds

	// using a fraction in integer arithmetic

	iMicroConvNum = 1000000;

	iMicroConvDen = frequency;

	TInt countsUp;

	User::LeaveIfError(HAL::Get(HAL::EFastCounterCountsUp, countsUp));

	iSystemClockReversed = !countsUp;

#elif defined(USE_NTICKCOUNT)

	User::LeaveIfError(HAL::Get(HAL::ENanoTickPeriod, iMicroConvNum)); // tick period in microseconds

	iMicroConvDen = 1;

#else	

#error

#endif

	// divide out any common factor to reduce chance of overflow

	TInt factor = LargestCommonFactor(iMicroConvNum, iMicroConvDen);

	iMicroConvNum /= factor;

	iMicroConvDen /= factor;

	// wraparound time in microseconds is 2^32 * iMicroConv

	// take the heartbeat interval as half of this (i.e shift left by 31 places) to ensure we wake up often enough to implement the carry properly

	TUint64 interval = (static_cast<TUint64>(iMicroConvNum) << 31) / iMicroConvDen;

	if (interval > KMaxTInt32)

		{

		iHeartbeatTimerInterval = KMaxTInt32;

		}

	else

		{

		iHeartbeatTimerInterval = interval;

		}

	// if denominator is a power of 2, use shift instead

	// (shifting is faster than division)

	if(iMicroConvDen & (iMicroConvDen - 1) == 0)

		{

		// PRECONDITION:  iMicroConvDen = 2^n, iMicroConvShift = 0

		// POSTCONDITION: iMicroConvDen = 1,   iMicroConvShift = n

		while(iMicroConvDen >= 2)

			{

			iMicroConvDen >>= 1;

			iMicroConvShift++;

			}

		}

	// Create the locks

	User::LeaveIfError(iQueMutex.CreateLocal());

	// Create the memory block of empty Time requests that make up the free list.

	iRequestBlock = new(ELeave) TMediaRequest [iMaxRequests];

	// zero the fields for peace of mind

	Mem::FillZ(iRequestBlock, (sizeof(TMediaRequest)*iMaxRequests));

   	// Initialise the free list

   	for(TInt requestIndex = 0; requestIndex < iMaxRequests; requestIndex++)

   		{

   		// Add all free items with delta 0

   		iFreeRequestQue.Add(iRequestBlock+requestIndex, static_cast<TInt64>(0));

   		}

   	iStartTimes.ReserveL(KNumPorts);

   	for(TInt portIndex = 0; portIndex < KNumPorts; portIndex++)

   		{

   		iStartTimes.Append(0);

   		}

	__ASSERT_DEBUG(iMaxRequests == iFreeRequestQue.Count(), Panic(ERequestQueueCorrupt));

	// Create the timer consumer thread

	TBuf<19> threadName;

	threadName.Format(_L("OmxILClock@%08X"), this);

	// Timer created on creation of the thread as it is thread relative

	User::LeaveIfError(iThread.Create(threadName, ThreadEntryPoint, KThreadStackSize, NULL, this));

	// High priority thread

	iThread.SetPriority(EPriorityRealTime);

	// start the thread and wait for it to create the timer

	TRequestStatus status;

	iThread.Rendezvous(status);

	iThread.Resume();

	iThreadStarted = ETrue;

	User::WaitForRequest(status);

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

	}

/**

 *

 *

 */

CClockSupervisor::CClockSupervisor(COmxILClockProcessingFunction& aProcessingFunction) 

:	iActiveRefClock(OMX_TIME_RefClockAudio),

	iMaxRequests(KMaxRequests),

	iProcessingFunction(aProcessingFunction)

	{

	// compile time assertion that fields requiring atomic access are 

	// 4-byte aligned

	__ASSERT_COMPILE((_FOFF(CClockSupervisor, iWallTicks) & 3) == 0);

	// run time assertion that class itself is allocated on a 4-byte boundary

	__ASSERT_ALWAYS((reinterpret_cast<TInt>(this) & 3) == 0, Panic(EBadAlignment));

	iMediaClockState.nSize = sizeof(iMediaClockState);

	iMediaClockState.nVersion = TOmxILSpecVersion();

	iMediaClockState.eState = OMX_TIME_ClockStateStopped;

	iCancelStatus = KRequestPending;

	}

/**

 *

 *

 */

CClockSupervisor::~CClockSupervisor()

	{

	// signal the timing thread and wait for it to terminate

	if(iThreadStarted)

		{

		iThreadRunning = EFalse;

		TRequestStatus logonStatus;

		iThread.Logon(logonStatus);

		// Want the thread to terminate ASAP instead of waiting for a media

		// time request completion or a wall time heartbeat. Can't cancel the

		// timer without duplicating the handle, and that gives

		// KErrPermissionDenied. So we use a second TRequestStatus to wake the

		// timing thread before the timer completes.

		TRequestStatus* cancelStatus = &iCancelStatus;

		iThread.RequestComplete(cancelStatus, KErrCancel);

		User::WaitForRequest(logonStatus);

		}

	if (iRequestBlock)

		{

		delete[] iRequestBlock;

		iRequestBlock = NULL;

		}

	iStartTimes.Close();

	iThread.Close();

	iQueMutex.Close();

	}

/**

 * Timing thread entry point.

 */

TInt CClockSupervisor::ThreadEntryPoint(TAny* aPtr)

	{

	CClockSupervisor& supervisor = *static_cast<CClockSupervisor*>(aPtr);

	supervisor.iThreadRunning = ETrue;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(cleanup == NULL)

		{

		return KErrNoMemory;

		}

	// Delegate to object's clock timing routine

	TRAPD(err, supervisor.RunTimingThreadL());

	delete cleanup;

	return err;

	}

/**

 *

 *

 */

void CClockSupervisor::RunTimingThreadL()

	{

	// Create the timer (thread relative)

	User::LeaveIfError(iTimer.CreateLocal());

	// rendezvous with the creating thread as it must be blocked until the timer is created

	iThread.Rendezvous(KErrNone);

	// Start the timer loop to enable us to wake up on heart beat or requests

	TimerLoop();

	iTimer.Close();

	}

/**

 * Services media time requests.

 */

void CClockSupervisor::TimerLoop()

	{

	// Here we are only interested in setting the timer for a request timeout

	// or the heart beat. States are taken care of in ConsumeRequests().

	// On shutdown the flag iThreadRunning is set to EFalse and the timer

	// completed with KErrCancel or something other than KRequestPending

	// Therefore we no longer try to get another request.

	TInt measuredTimerOverhead = KTimerQuantization;

	TRequestStatus timerStatus;

	while(iThreadRunning)

		{

		// Call our consumer function

		TInt timeout = ConsumeRequests();

		// round down sleep based on overhead and quantization of timers

		timeout -= timeout % KTimerQuantization;

		timeout -= measuredTimerOverhead;

		timeout -= KMinTimerOverhead;

		// limit sleep by the heartbeat interval

		if(timeout > iHeartbeatTimerInterval)

			{

			timeout = iHeartbeatTimerInterval;

			}

		// Perhaps timeout not positive from ConsumeRequests(), or due to

		// rounding down it is no longer positive. In this case we may spin, so

		// be careful when setting KTimerQuantization, KMinTimerOverhead and

		// KRequestDeltaLimit

		if(timeout <= 0)

			{

			continue;

			}

		iQueMutex.Wait();

		TInt64 actualSleepTime = WallTime();

		iQueMutex.Signal();

		iTimer.HighRes(timerStatus, timeout);			

		// can't cancel iTimer from another thread, instead we use a second

		// TRequestStatus to wake up early, then we can cancel the timer in

		// this thread.

		User::WaitForRequest(timerStatus, iCancelStatus);

		if(iCancelStatus.Int() != KRequestPending)

			{

			iTimer.Cancel();

			iCancelStatus = KRequestPending;

			}

		else

			{

			// update measuredTimerOverhead

			iQueMutex.Wait();

			actualSleepTime = WallTime() - actualSleepTime;

			iQueMutex.Signal();

			TInt sleepOverhead = (TInt) (actualSleepTime - timeout);

			/* Dampen adjustments to measuredTimerOverhead

			 * 

			 *   measuredTimerOverhead = max(sleepOverhead,

			 *                           avg(measuredTimerOverhead, sleepOverhead))

			 * 

			 * i.e. immediate increase, gradual decrease

			 */

			measuredTimerOverhead = (measuredTimerOverhead + sleepOverhead) >> 1;

			if(measuredTimerOverhead < sleepOverhead)

				{

				measuredTimerOverhead = sleepOverhead;

				}

			}

		}

	DEBUG_PRINTF(_L("Clock thread shutting down..."));

	}

/**

 * Update the wall clock with the system ticks

 *

 */

void CClockSupervisor::UpdateWallTicks()

	{

	__ASSERT_DEBUG(iQueMutex.IsHeld(), Panic(EMutexUnheld));

	TUint32 oldLowPart(I64LOW(iWallTicks));		// save lower 32-bits

#ifdef USE_FASTCOUNTER

	// Gets the fast iCounter.

	// This is the current value of the machine's high resolution timer. 

	// If a high resolution timer is not available, it uses the millisecond timer instead.

	// The freqency of this iCounter can be determined by reading the HAL attribute EFastCounterFrequency.

	TUint32 newLowPart(User::FastCounter());	// set lower 32-bits

	if(iSystemClockReversed)

		{

		newLowPart = -newLowPart;

		}

#elif defined(USE_NTICKCOUNT)

	TUint32 newLowPart(User::NTickCount());		// set lower 32-bits

#else

#error

#endif

	TUint32 newHighPart(I64HIGH(iWallTicks));	// save upper 32-bits

	// note: did not use LockedInc() here because:

	// We need a critical section to capture the system time and update the wall clock

	// at the same time.

	// The wall clock is unsigned.

	// LockedInc doesn't stop a preemption directly after the test, only during the inc	

	if (newLowPart < oldLowPart) 

		{

		newHighPart++;

		}

	iWallTicks = MAKE_TUINT64(newHighPart,newLowPart);

	}

/**

 * Returns the current wall time in microseconds.

 */

TInt64 CClockSupervisor::WallTime()

	 {

	 __ASSERT_DEBUG(iQueMutex.IsHeld(), Panic(EMutexUnheld));

	 UpdateWallTicks();

	 // if power of two use shift (faster than division)

	 if (iMicroConvDen == 1)

		 {

		 return iWallTicks * iMicroConvNum >> iMicroConvShift;

		 }

	 return iWallTicks * iMicroConvNum / iMicroConvDen;

	 }

/**

 *

 *

 */

TBool CClockSupervisor::AllStartTimesReported ()

	{

	return !(static_cast<TBool>(iMediaClockState.nWaitMask));

	}

/**

 * Called when timer expires or is cancelled.

 *

 */

TInt CClockSupervisor::ConsumeRequests()

	{

	// Events are consumed here only in the Running state.

	// Waiting events, State change events, etc. are handled elsewhere.

	// These are called broadcast events and have a higher priority 

	// than the request events requested by the clients.

	// This function is called by the TimerLoop only.

	// IMPORTANT: every code path through here must result in a call to UpdateWallTicks to ensure

	// that 64-bit time is updated correctly (heartbeat interval makes sure ConsumeRequests is called

	// often enough).

	// Our event loop - return if stopped but not for pause (keep heart beat going)

	if(OMX_TIME_ClockStateStopped != iMediaClockState.eState)

		{

		// Acquire the mutex

		iQueMutex.Wait();

		// this can be entered from the timer on heartbeat or on a call to a state change. 

		// Don't want this to happen on a state change!

		if (OMX_TIME_ClockStateWaitingForStartTime == iMediaClockState.eState)

			{

			// We need to check if all clients have reported their start times

			if (!AllStartTimesReported())

				{

				// Not all reported as yet...

				UpdateWallTicks();

				// Release the mutex

				iQueMutex.Signal();

				// wait until they have! keep heat beat going in case it takes looooong!

				return iHeartbeatTimerInterval;

				}

			else

				{

				// depending on scale decide which start time to use

				CalculateStartTime();

				// no need to check error, we are in the waiting state

				DoTransitionToRunningState();

				// Now just go and send the iNext request!

				}

			}

		///////////////////////////////

		// There is a request pending !!!

		// 

		// check the timeout period against the wall clock to determine if this is a heart beat

		if(iMtc.iScaleQ16 == 0)

			{

			// do not pop front of the queue because we are effectively paused

			UpdateWallTicks();

			// Release the mutex