// Copyright (c) 2003-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:

 //

 #include "devvideobase.h"

 #include "devvideoconstants.h"

 //Include the following headers here just to check they can be compiled OK. 

 #include "Mpeg4Visual.h"

 #include "AVC.h"

 #include "H263.h"

 #include "vc1.h"

 #include "on2vp6.h"

 #include "sorensonspark.h"

 EXPORT_C CCompressedVideoFormat* CCompressedVideoFormat::NewL(const TDesC8& aMimeType,const TDesC8& aOptionalData)

 	{

 	CCompressedVideoFormat* s = new(ELeave) CCompressedVideoFormat;

 	CleanupStack::PushL(s);

 	s->ConstructL(aMimeType, aOptionalData);

 	CleanupStack::Pop(s);

 	return s;

 	}

 EXPORT_C CCompressedVideoFormat* CCompressedVideoFormat::NewL(const CCompressedVideoFormat& aFormat)

 	{

 	CCompressedVideoFormat* s = new(ELeave) CCompressedVideoFormat;

 	CleanupStack::PushL(s);

 	s->ConstructL(aFormat.MimeType(), aFormat.OptionalData());

 	CleanupStack::Pop(s);

 	return s;

 	}

 EXPORT_C CCompressedVideoFormat::~CCompressedVideoFormat()

 	{

 	delete iMimeType;

 	delete iOptionalData;

 	}

 EXPORT_C const TDesC8& CCompressedVideoFormat::MimeType() const

 	{

 	return *iMimeType;

 	}

 EXPORT_C const TDesC8& CCompressedVideoFormat::OptionalData() const

 	{

 	return *iOptionalData;

 	}

 CCompressedVideoFormat::CCompressedVideoFormat()

 	{

 	}

 void CCompressedVideoFormat::ConstructL(const TDesC8& aMimeType, const TDesC8& aOptionalData)

 	{

 	iMimeType = aMimeType.AllocL();

 	iOptionalData = aOptionalData.AllocL();

 	}

 EXPORT_C TBool CCompressedVideoFormat::operator==(const CCompressedVideoFormat& aOther) const

 	{

 	TBool retval = EFalse;

 	// only test optionalData if aOther has an optional data of length > 0.  Need a

 	// check like this for performing matches on mimetype only.

 	if (aOther.OptionalData().Length() > 0)

 		retval = ((aOther.MimeType().CompareF(*iMimeType) == 0) && (aOther.OptionalData().CompareF(*iOptionalData) == 0));

 	else

 		retval = ((aOther.MimeType().CompareF(*iMimeType) == 0));

 	return retval;

 	}

 EXPORT_C CSystemClockSource* CSystemClockSource::NewL()

 	{

 	CSystemClockSource* s = new(ELeave) CSystemClockSource;

 	CleanupStack::PushL(s);

 	s->ConstructL();

 	CleanupStack::Pop(s);

 	return s;

 	}

 CSystemClockSource::CSystemClockSource()

 	{

 	iStartTime.UniversalTime();

 	iTimeSuspended = 0;

 	}

 void CSystemClockSource::ConstructL()

 	{

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

 	}

 EXPORT_C CSystemClockSource::~CSystemClockSource()

 	{

 	iCriticalSection.Close();

 	}

 TAny* CSystemClockSource::CustomInterface(TUid /*aInterface*/)

 	{

 	return NULL;

 	}

 EXPORT_C void CSystemClockSource::Reset()

 	{

 	iCriticalSection.Wait();

 	iStartTime.UniversalTime();

 	iOffset = 0;

 	iTimeSuspended = 0;

 	iCriticalSection.Signal();

 	}

 EXPORT_C void CSystemClockSource::Reset(const TTimeIntervalMicroSeconds& aOffset)

 	{

 	iCriticalSection.Wait();

 	iStartTime.UniversalTime();

 	iOffset = aOffset;

 	iTimeSuspended = 0;

 	iCriticalSection.Signal();

 	}

 TTimeIntervalMicroSeconds CSystemClockSource::Time()

 	{

 	iCriticalSection.Wait();

 	TTimeIntervalMicroSeconds elapsed(0);

 	if (!iSuspended)

 		{

 		iCurrentTime.UniversalTime();

 		elapsed = iCurrentTime.MicroSecondsFrom(iStartTime);

 		}

 	else

 		{

 		// If we're currently suspended, current time == time when we were suspended

 		elapsed = iTimeWhenSuspended.MicroSecondsFrom(iStartTime);

 		}

 	// Perceived elapsed time == true elapsed + offset - time spent suspended

 	TInt64 time = elapsed.Int64() + iOffset.Int64() - iTimeSuspended.Int64();

 	iCriticalSection.Signal();

 	return time;

 	}

 EXPORT_C void CSystemClockSource::Suspend()

 	{

 	__ASSERT_DEBUG(!iSuspended, DevVideoPanic(EDevVideoPanicPreConditionViolation));

 	iCriticalSection.Wait();

 	iTimeWhenSuspended.UniversalTime();

 	iSuspended = ETrue;

 	iCriticalSection.Signal();

 	}

 EXPORT_C void CSystemClockSource::Resume()

 	{

 	__ASSERT_DEBUG(iSuspended, DevVideoPanic(EDevVideoPanicPreConditionViolation));

 	iCriticalSection.Wait();

 	iSuspended = EFalse;

 	iCurrentTime.UniversalTime();

 	iTimeSuspended = iTimeSuspended.Int64() + iCurrentTime.MicroSecondsFrom(iTimeWhenSuspended).Int64();

 	iCriticalSection.Signal();

 	}

 EXPORT_C CMMFClockSourcePeriodicUtility* CMMFClockSourcePeriodicUtility::NewL(MMMFClockSource& aClockSource, MMMFClockSourcePeriodicUtilityObserver& aObserver)

 	{

 	CMMFClockSourcePeriodicUtility* s = new(ELeave) CMMFClockSourcePeriodicUtility(aClockSource, aObserver);

 	CleanupStack::PushL(s);

 	s->ConstructL();

 	CleanupStack::Pop(s);

 	return s;

 	}

 CMMFClockSourcePeriodicUtility::CMMFClockSourcePeriodicUtility(MMMFClockSource& aClockSource, MMMFClockSourcePeriodicUtilityObserver& aObserver) :

 	iClockSource(aClockSource),

 	iObserver(aObserver)

 	{

 	}

 void CMMFClockSourcePeriodicUtility::ConstructL()

 	{

 	iTimer = CPeriodic::NewL(EPriorityNormal);

 	}

 EXPORT_C void CMMFClockSourcePeriodicUtility::Start(TTimeIntervalMicroSeconds32 aPeriod)

 	{

 	TCallBack callback(CMMFClockSourcePeriodicUtility::Callback, this);

 	iTimer->Start(aPeriod, aPeriod, callback);

 	}

 EXPORT_C void CMMFClockSourcePeriodicUtility::Stop()

 	{

 	iTimer->Cancel();

 	}

 EXPORT_C CMMFClockSourcePeriodicUtility::~CMMFClockSourcePeriodicUtility()

 	{

 	delete iTimer;

 	}

 TInt CMMFClockSourcePeriodicUtility::Callback(TAny* aAny)

 	{

 	CMMFClockSourcePeriodicUtility* me = reinterpret_cast<CMMFClockSourcePeriodicUtility*>(aAny);

 	me->DoCallback();

 	return KErrNone;

 	}

 void CMMFClockSourcePeriodicUtility::DoCallback()

 	{

 	iObserver.MmcspuoTick(iClockSource.Time());

 	}