// 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());
	}