// 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 <ecom/ecom.h>

#ifdef SYMBIAN_MULTIMEDIA_CODEC_API	

#include <mdf/codecapiuids.hrh>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/devvideo/devvideohwdeviceadaptersetup.h>

#endif

#endif // SYMBIAN_MULTIMEDIA_CODEC_API

#include "devvideoplay.h"

#include "videoplayhwdevice.h"

#include "devvideointernal.h"

#include <mm/mmpluginutils.h>

const THwDeviceId KHwDeviceIdVideoDecoder = 1;

const THwDeviceId KHwDeviceIdVideoPostProcessor = 2;

//

// CMMFVideoDecodeHwDevice

//

EXPORT_C CMMFVideoDecodeHwDevice* CMMFVideoDecodeHwDevice::NewL(TUid aUid, MMMFDevVideoPlayProxy& aProxy)

	{

	CMMFVideoDecodeHwDevice* s = reinterpret_cast<CMMFVideoDecodeHwDevice*> 

		(REComSession::CreateImplementationL(aUid, _FOFF(CMMFVideoDecodeHwDevice,iDtor_ID_Key)));

	s->SetProxy(aProxy);

	return s;

	}

#ifdef SYMBIAN_MULTIMEDIA_CODEC_API	

const TInt KUidMDFVideoDecoderHwDeviceAdapter = 0x102737ED;

EXPORT_C CMMFVideoDecodeHwDevice* CMMFVideoDecodeHwDevice::NewPuAdapterL(const CImplementationInformation& aInfo, MMMFDevVideoPlayProxy& aProxy)

	{

	CMMFVideoDecodeHwDevice* hwdevice = NewL(TUid::Uid(KUidMDFVideoDecoderHwDeviceAdapter), aProxy);

	CleanupStack::PushL(hwdevice);

	MDevVideoHwDeviceAdapterSetup* setup = static_cast<MDevVideoHwDeviceAdapterSetup*>(

			hwdevice->CustomInterface(TUid::Uid(KUidDevVideoHwDeviceAdapterSetup)));

	if (setup!=NULL)

		{

		setup->LoadProcessingUnitL(aInfo);

		}

	CleanupStack::Pop(hwdevice);

	return hwdevice;

	}

#else

EXPORT_C CMMFVideoDecodeHwDevice* CMMFVideoDecodeHwDevice::NewPuAdapterL(const CImplementationInformation& /*aInfo*/, MMMFDevVideoPlayProxy& /*aProxy*/)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

#endif // SYMBIAN_MULTIMEDIA_CODEC_API

EXPORT_C CMMFVideoDecodeHwDevice::~CMMFVideoDecodeHwDevice()

	{

	REComSession::DestroyedImplementation(iDtor_ID_Key);

	}

EXPORT_C CMMFVideoDecodeHwDevice::CMMFVideoDecodeHwDevice()

	{

	}

//

// CMMFVideoPostProcHwDevice

//

EXPORT_C CMMFVideoPostProcHwDevice* CMMFVideoPostProcHwDevice::NewL(TUid aUid, MMMFDevVideoPlayProxy& aProxy)

	{

	CMMFVideoPostProcHwDevice* s = reinterpret_cast<CMMFVideoPostProcHwDevice*>

		(REComSession::CreateImplementationL(aUid, _FOFF(CMMFVideoPostProcHwDevice,iDtor_ID_Key)));

	s->SetProxy(aProxy);

	return s;

	}

EXPORT_C CMMFVideoPostProcHwDevice::~CMMFVideoPostProcHwDevice()

	{

	REComSession::DestroyedImplementation(iDtor_ID_Key);

	}

EXPORT_C CMMFVideoPostProcHwDevice::CMMFVideoPostProcHwDevice()

	{

	}

EXPORT_C TVideoInputBuffer::TVideoInputBuffer() :

	iData(0,0,0),

	iOptions(0),

	iDecodingTimestamp(0),

	iPresentationTimestamp(0),

	iPreRoll(EFalse),

	iSequenceNumber(0),

	iError(EFalse),

	iUser(NULL)

	{

	}

//

// CPostProcessorInfo

//

EXPORT_C CPostProcessorInfo* CPostProcessorInfo::NewL(TUid aUid,

													 const TDesC& aManufacturer,

													 const TDesC& aIdentifier,

													 TVersion aVersion,

													 const TArray<TUncompressedVideoFormat>& aSupportedFormats,

													 const TArray<TUint32>& aSupportedCombinations,

													 TBool aAccelerated,

													 TBool aSupportsDirectDisplay,

													 const TYuvToRgbCapabilities& aYuvToRgbCapabilities,

													 TUint32 aSupportedRotations,

													 TBool aSupportArbitraryScaling,

													 const TArray<TScaleFactor>& aSupportedScaleFactors,

													 TBool aAntiAliasedScaling,

													 const TDesC8& aImplementationSpecificInfo)

	{

	CPostProcessorInfo* s = new(ELeave) CPostProcessorInfo(aUid, 

														   aVersion, 

														   aAccelerated,

														   aSupportsDirectDisplay, 

														   aYuvToRgbCapabilities, 

														   aSupportedRotations, 

														   aSupportArbitraryScaling,

														   aAntiAliasedScaling);

	CleanupStack::PushL(s);

	s->ConstructL(aManufacturer,

				  aIdentifier,

				  aSupportedFormats,

				  aSupportedCombinations,

				  aSupportedScaleFactors,

				  aImplementationSpecificInfo);

	CleanupStack::Pop(s);

	return s;

	}

CPostProcessorInfo::CPostProcessorInfo(TUid aUid,

									   TVersion aVersion,

									   TBool aAccelerated,

									   TBool aSupportDirectDisplay,

									   const TYuvToRgbCapabilities& aYuvToRgbCapabilities,

									   TUint32 aSupportedRotations,

									   TBool aSupportArbitraryScaling,

									   TBool aAntiAliasedScaling) :

	iUid(aUid),

	iVersion(aVersion),

	iAccelerated(aAccelerated),

	iSupportDirectDisplay(aSupportDirectDisplay),

	iYuvToRgbCapabilities(aYuvToRgbCapabilities),

	iSupportedRotations(aSupportedRotations),

	iSupportArbitraryScaling(aSupportArbitraryScaling),

	iAntiAliasedScaling(aAntiAliasedScaling),

	iSupportsContentProtected(EFalse)

	{

	iSupportedScreens.Reset();

	}

void CPostProcessorInfo::ConstructL(const TDesC& aManufacturer,

									const TDesC& aIdentifier,

									const TArray<TUncompressedVideoFormat>& aSupportedFormats,

									const TArray<TUint32>& aSupportedCombinations,

									const TArray<TScaleFactor>& aSupportedScaleFactors,

									const TDesC8& aImplementationSpecificInfo)

	{

	iManufacturer = aManufacturer.AllocL();

	iIdentifier = aIdentifier.AllocL();

	iImplementationSpecificInfo = aImplementationSpecificInfo.AllocL();

	TInt i=0;

	TInt supportedFormatsCount = aSupportedFormats.Count();

	for (i=0; i<supportedFormatsCount; i++)

		{

		User::LeaveIfError(iSupportedFormats.Append(aSupportedFormats[i]));

		}

	TInt supportedCombinationsCount = aSupportedCombinations.Count();

	for (i=0; i<supportedCombinationsCount; i++)

		{

		User::LeaveIfError(iSupportedCombinations.Append(aSupportedCombinations[i]));

		}

	TInt supportedScaleFactors = aSupportedScaleFactors.Count();

	for (i=0; i<supportedScaleFactors; i++)

		{

		User::LeaveIfError(iSupportedScaleFactors.Append(aSupportedScaleFactors[i]));

		}

	}

EXPORT_C CPostProcessorInfo::~CPostProcessorInfo()

	{

	delete iManufacturer;

	delete iIdentifier;

	delete iImplementationSpecificInfo;

	iSupportedFormats.Reset();

	iSupportedCombinations.Reset();

	iSupportedScaleFactors.Reset();

	iSupportedScreens.Close();

	}

EXPORT_C TUid CPostProcessorInfo::Uid() const

	{

	return iUid;

	}

EXPORT_C const TDesC& CPostProcessorInfo::Manufacturer() const

	{

	return *iManufacturer;

	}

EXPORT_C const TDesC& CPostProcessorInfo::Identifier() const

	{

	return *iIdentifier;

	}

EXPORT_C TVersion CPostProcessorInfo::Version() const

	{

	return iVersion;

	}

EXPORT_C TBool CPostProcessorInfo::SupportsFormat(const TUncompressedVideoFormat& aFormat) const

	{

	TBool found = EFalse;

	TInt count = iSupportedFormats.Count();

	for (TInt i=0; i<count; i++)

		{

		if (iSupportedFormats[i] == aFormat)

			{

			found = ETrue;

			break;

			}

		}

	return found;

	}

EXPORT_C const RArray<TUncompressedVideoFormat>& CPostProcessorInfo::SupportedFormats() const

	{

	return iSupportedFormats;

	}

EXPORT_C TBool CPostProcessorInfo::SupportsCombination(TUint32 aCombination) const

	{

	TBool found = EFalse;

	TInt count = iSupportedCombinations.Count();

	for (TInt i=0; i<count; i++)

		{

		if (iSupportedCombinations[i] == aCombination)

			{

			found = ETrue;

			break;

			}

		}

	return found;

	}

EXPORT_C const RArray<TUint32>& CPostProcessorInfo::SupportedCombinations() const

	{

	return iSupportedCombinations;

	}

EXPORT_C TBool CPostProcessorInfo::Accelerated() const

	{

	return iAccelerated;

	}

EXPORT_C TBool CPostProcessorInfo::SupportsDirectDisplay() const

	{

	return iSupportDirectDisplay;

	}

EXPORT_C const TYuvToRgbCapabilities& CPostProcessorInfo::YuvToRgbCapabilities() const

	{

	return iYuvToRgbCapabilities;

	}

EXPORT_C TUint32 CPostProcessorInfo::SupportedRotations() const

	{

	return iSupportedRotations;

	}

EXPORT_C TBool CPostProcessorInfo::SupportsArbitraryScaling() const

	{

	return iSupportArbitraryScaling;

	}

EXPORT_C const RArray<TScaleFactor>& CPostProcessorInfo::SupportedScaleFactors() const

	{

	return iSupportedScaleFactors;

	}

EXPORT_C TBool CPostProcessorInfo::AntiAliasedScaling() const

	{

	return iAntiAliasedScaling;

	}

EXPORT_C const TDesC8& CPostProcessorInfo::ImplementationSpecificInfo() const

	{

	return *iImplementationSpecificInfo;

	}

EXPORT_C void CPostProcessorInfo::AddSupportedScreenL(TInt aScreenNo)

	{

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

	iSupportedScreens.AppendL(aScreenNo);

#else

	aScreenNo = aScreenNo; //Added to remove the warning

	User::Leave(KErrNotSupported);

#endif

	}

EXPORT_C void CPostProcessorInfo::GetSupportedScreensL(RArray<TInt>& aSupportedScreens) const

	{

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

	aSupportedScreens.Reset();

	TInt screensCount = iSupportedScreens.Count();

	for (TInt i = 0; i < screensCount;i++)

		{

		aSupportedScreens.AppendL(iSupportedScreens[i]);

		}

#else

	aSupportedScreens = aSupportedScreens;//Added to remove the warning

	User::Leave(KErrNotSupported);

#endif

	}

EXPORT_C void CPostProcessorInfo::SetSupportsContentProtected(const TBool aSetting)

	{

	iSupportsContentProtected = aSetting;

	}

EXPORT_C TBool CPostProcessorInfo::SupportsContentProtected() const

	{

	return iSupportsContentProtected;

	}

//

// CVideoDecoderInfo

//

EXPORT_C CVideoDecoderInfo* CVideoDecoderInfo::NewL(TUid aUid,

													const TDesC& aManufacturer,

													const TDesC& aIdentifier,

													TVersion aVersion,

													const TArray<CCompressedVideoFormat*>& aSupportedFormats,

													TBool aAccelerated,

													TBool aSupportsDirectDisplay,

													const TSize& aMaxPictureSize,

													TUint aMaxBitrate,

													const TArray<TPictureRateAndSize>& aMaxPictureRates,

													TBool aSupportsPictureLoss,

													TBool aSupportsSliceLoss,

													const TDesC8& aCodingStandardSpecificInfo,

													const TDesC8& aImplementationSpecificInfo)

	{

	CVideoDecoderInfo* s = new(ELeave) CVideoDecoderInfo(aUid,

														 aVersion,

														 aAccelerated,

														 aSupportsDirectDisplay,

														 aMaxPictureSize,

														 aMaxBitrate,

														 aSupportsPictureLoss,

														 aSupportsSliceLoss);

	CleanupStack::PushL(s);

	s->ConstructL(aManufacturer, aIdentifier, aSupportedFormats, aMaxPictureRates, aCodingStandardSpecificInfo, aImplementationSpecificInfo);

	CleanupStack::Pop(s);

	return s;

	}

CVideoDecoderInfo::CVideoDecoderInfo(TUid aUid,

									 TVersion aVersion,

									 TBool aAccelerated,

									 TBool aSupportsDirectDisplay,

									 const TSize& aMaxPictureSize,

								     TUint aMaxBitrate,

								     TBool aSupportsPictureLoss,

								     TBool aSupportsSliceLoss) :

	iUid(aUid),

	iVersion(aVersion),

	iAccelerated(aAccelerated),

	iSupportsDirectDisplay(aSupportsDirectDisplay),

	iMaxPictureSize(aMaxPictureSize),

	iMaxBitrate(aMaxBitrate),

	iSupportsPictureLoss(aSupportsPictureLoss),

	iSupportsSliceLoss(aSupportsSliceLoss),

	iSupportsContentProtected(EFalse)

	{

	iSupportedScreens.Reset();

	}

void CVideoDecoderInfo::ConstructL(const TDesC& aManufacturer,

								   const TDesC& aIdentifier,

								   const TArray<CCompressedVideoFormat*>& aSupportedFormats,

								   const TArray<TPictureRateAndSize>& aMaxPictureRates,

								   const TDesC8& aCodingStandardSpecificInfo,

								   const TDesC8& aImplementationSpecificInfo)

	{

	iManufacturer = aManufacturer.AllocL();

	iIdentifier = aIdentifier.AllocL();

	iCodingStandardSpecificInfo = aCodingStandardSpecificInfo.AllocL();

	iImplementationSpecificInfo = aImplementationSpecificInfo.AllocL();

	TInt i=0;

	TInt count = aSupportedFormats.Count();

	for (i=0; i<count; i++)

		{

		CCompressedVideoFormat* f = CCompressedVideoFormat::NewL(*(aSupportedFormats[i]));

		CleanupStack::PushL(f);

		User::LeaveIfError(iSupportedFormats.Append(f));

		CleanupStack::Pop(f);

		}

	count = aMaxPictureRates.Count();

	for (i=0; i<count; i++)

		{

		User::LeaveIfError(iMaxPictureRates.Append(aMaxPictureRates[i]));

		}

	}

EXPORT_C CVideoDecoderInfo::~CVideoDecoderInfo()

	{

	delete iManufacturer;

	delete iIdentifier;

	delete iCodingStandardSpecificInfo;

	delete iImplementationSpecificInfo;

	iSupportedFormats.ResetAndDestroy();

	iSupportedFormats.Close();

	iMaxPictureRates.Reset();

	iMaxPictureRates.Close();

	iSupportedScreens.Close();

	}

EXPORT_C TBool CVideoDecoderInfo::SupportsFormat(const CCompressedVideoFormat& aFormat) const

	{

	TBool result = EFalse;

	TInt count = iSupportedFormats.Count();

	for (TInt i=0; i<count; i++)

		{

		if (*(iSupportedFormats[i]) == aFormat)

			{

			result = ETrue;

			break;

			}

		}

	return result;

	}

EXPORT_C const RPointerArray<CCompressedVideoFormat>& CVideoDecoderInfo::SupportedFormats() const

	{

	return iSupportedFormats;

	}

EXPORT_C const TDesC& CVideoDecoderInfo::Manufacturer() const

	{

	return *iManufacturer;

	}

EXPORT_C const TDesC& CVideoDecoderInfo::Identifier() const

	{

	return *iIdentifier;

	}

EXPORT_C TVersion CVideoDecoderInfo::Version() const

	{

	return iVersion;

	}

EXPORT_C TUid CVideoDecoderInfo::Uid() const

	{

	return iUid;

	}

EXPORT_C TBool CVideoDecoderInfo::Accelerated() const

	{

	return iAccelerated;

	}

EXPORT_C TBool CVideoDecoderInfo::SupportsDirectDisplay() const

	{

	return iSupportsDirectDisplay;

	}

EXPORT_C const TSize& CVideoDecoderInfo::MaxPictureSize() const

	{

	return iMaxPictureSize;

	}

EXPORT_C TUint CVideoDecoderInfo::MaxBitrate() const

	{

	return iMaxBitrate;

	}

EXPORT_C const RArray<TPictureRateAndSize>& CVideoDecoderInfo::MaxPictureRates() const

	{

	return iMaxPictureRates;

	}

EXPORT_C TBool CVideoDecoderInfo::SupportsPictureLoss() const

	{

	return iSupportsPictureLoss;

	}

EXPORT_C TBool CVideoDecoderInfo::SupportsSliceLoss() const

	{

	return iSupportsSliceLoss;

	}

EXPORT_C const TDesC8& CVideoDecoderInfo::CodingStandardSpecificInfo() const

	{

	return *iCodingStandardSpecificInfo;

	}

EXPORT_C const TDesC8& CVideoDecoderInfo::ImplementationSpecificInfo() const

	{

	return *iImplementationSpecificInfo;

	}

EXPORT_C void CVideoDecoderInfo::AddSupportedScreenL(TInt aScreenNo)

	{

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

	iSupportedScreens.AppendL(aScreenNo);

#else

	aScreenNo = aScreenNo; //Added to remove the warning.

	User::Leave(KErrNotSupported);

#endif

	}

EXPORT_C void CVideoDecoderInfo::GetSupportedScreensL(RArray<TInt>& aSupportedScreens) const

	{

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

	aSupportedScreens.Reset();

	TInt screensCount = iSupportedScreens.Count();

	for (TInt i = 0; i < screensCount;i++)

		{

		aSupportedScreens.AppendL(iSupportedScreens[i]);

		}

#else

	aSupportedScreens = aSupportedScreens;//Added to remove the warning

	User::Leave(KErrNotSupported);

#endif

	}

EXPORT_C void CVideoDecoderInfo::SetSupportsContentProtected(const TBool aSetting)

	{

	iSupportsContentProtected = aSetting;

	}

EXPORT_C TBool CVideoDecoderInfo::SupportsContentProtected() const

	{

	return iSupportsContentProtected;

	}

//

// CMMFDevVideoPlay

//

EXPORT_C CMMFDevVideoPlay* CMMFDevVideoPlay::NewL(MMMFDevVideoPlayObserver& aObserver)

	{

	return new(ELeave) CMMFDevVideoPlay(aObserver);

	}

CMMFDevVideoPlay::CMMFDevVideoPlay(MMMFDevVideoPlayObserver& aObserver) :

	iObserver(aObserver),

	iInitializationState(ENotInitialized),

	iVideoPictureQue(_FOFF(TVideoPicture,iLink)),

	iVideoPictureQueIter(iVideoPictureQue)

	{

	}

EXPORT_C CMMFDevVideoPlay::~CMMFDevVideoPlay()

	{

	delete iVideoDecodeHwDevice;

	delete iVideoPostProcHwDevice;

#ifdef SYMBIAN_MULTIMEDIA_CODEC_API

	iPuImplementations.ResetAndDestroy();

#endif

	}

EXPORT_C TBool CMMFDevVideoPlay::FindCommonFormat(const TArray<TUncompressedVideoFormat>& aFormats1, const TArray<TUncompressedVideoFormat>& aFormats2, TUncompressedVideoFormat& aCommonFormat)

	{

	// Find the least expensive format common to both arrays.

	// Expense is proportional to array position, so do search twice, using each array as a base

	TInt formats1Position;

	TInt formats2Position;

	const TUncompressedVideoFormat* firstTry = NULL;

	TInt firstTryCumulativePosition = -1;

	const TUncompressedVideoFormat* secondTry = NULL;

	TInt secondTryCumulativePosition = -1;

	TInt formats1Count = aFormats1.Count();

	TInt formats2Count = aFormats2.Count();

	for (formats1Position=0; formats1Position < formats1Count; formats1Position++)

		{

		const TUncompressedVideoFormat& format1 = aFormats1[formats1Position];

		for (formats2Position=0; formats2Position < formats2Count; formats2Position++)

			{

			const TUncompressedVideoFormat& format2 = aFormats2[formats2Position];

			if (format1 == format2)

				{

				firstTry = &format1;

				firstTryCumulativePosition = formats1Position+formats2Position;

				break;

				}

			}

		if (firstTry != NULL)

			break;

		}

	for (formats2Position=0; formats2Position < formats2Count; formats2Position++)

		{

		const TUncompressedVideoFormat& format2 = aFormats2[formats2Position];

		for (formats1Position=0; formats1Position < formats1Count; formats1Position++)

			{

			const TUncompressedVideoFormat& format1 = aFormats1[formats1Position];

			if (format1 == format2)

				{

				secondTry = &format1;

				secondTryCumulativePosition = formats1Position+formats2Position;

				break;

				}

			}

		if (secondTry != NULL)

			break;

		}

	TBool found = EFalse;

	if (firstTry!=NULL)

		{

		ASSERT(secondTry!=NULL);

		found = ETrue;

		// Work out which is cheaper

		if (firstTryCumulativePosition <= secondTryCumulativePosition)

			{

			aCommonFormat = *firstTry;

			}

		else

			{

			aCommonFormat = *secondTry;

			}

		}

	return found;

	}

EXPORT_C void CMMFDevVideoPlay::FindDecodersL(const TDesC8& aMimeType, TUint32 aPostProcType, RArray<TUid>& aDecoders, TBool aExactMatch)

	{

#ifdef SYMBIAN_MULTIMEDIA_CODEC_API

	// find PU based plugins

	RImplInfoPtrArray codecPlugins;

	CleanupResetAndDestroyPushL(codecPlugins);

	DevVideoUtilities::FindVideoDecoderPluginsL(aMimeType, codecPlugins);	

	aDecoders.Reset();

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

		{

		aDecoders.AppendL(codecPlugins[i]->ImplementationUid());

		}

	CleanupStack::PopAndDestroy(&codecPlugins);

#endif // SYMBIAN_MULTIMEDIA_CODEC_API

	RImplInfoPtrArray plugins;

	CleanupResetAndDestroyPushL(plugins);

	MmPluginUtils::FindImplementationsL(KUidDevVideoDecoderHwDevice, plugins);

	DevVideoUtilities::SelectPluginBasedOnMatchType(aMimeType, plugins);

	DevVideoUtilities::MatchPrePostProcessorCapabilitiesL(plugins, aPostProcType, aDecoders);

	// Perform the extra processing required if an exact match was requested

	if (aExactMatch)

		{

		// We now need to go through each of the plugins returned (which may have been matched using

		// a wildcard), instantiate each one, and perform an exact mime-type match.

		// Any plugins that don't support the desired mime type exactly will be removed from aDecoders.

		CCompressedVideoFormat* format = CCompressedVideoFormat::NewL(aMimeType);

		CleanupStack::PushL(format);

		for (TInt i=aDecoders.Count()-1; i>=0; i--)

			{

			TUid pluginUid = aDecoders[i];

			CVideoDecoderInfo* info = NULL;

			TRAPD(err, info = VideoDecoderInfoLC(pluginUid); CleanupStack::Pop(info););

			if (err == KErrNone)

				{

				if (!info->SupportsFormat(*format))

					{

					// The decoder doesn't support the format, so remove it from the list

					aDecoders.Remove(i);

					}

				delete info;

				}

			else if (err==KErrNotFound)

				{

				// we have a bogus UID so remove it from the list

				aDecoders.Remove(i);

				}

			else

				{

				User::Leave(err);

				}

			}

		CleanupStack::PopAndDestroy(format);

		}

	// Leave if we didn't find anything.

	if (aDecoders.Count() == 0)

		{

		User::Leave(KErrNotFound);

		}

	CleanupStack::PopAndDestroy(&plugins);

	}

EXPORT_C void CMMFDevVideoPlay::FindPostProcessorsL(TUint32 aPostProcType, RArray<TUid>& aPostProcessors)

	{

	RImplInfoPtrArray plugins;

	CleanupResetAndDestroyPushL(plugins);

	MmPluginUtils::FindImplementationsL(KUidDevVideoPostProcessorHwDevice, plugins);

	DevVideoUtilities::MatchPrePostProcessorCapabilitiesL(plugins, aPostProcType, aPostProcessors);

	// Leave if we didn't find anything.

	if (aPostProcessors.Count() == 0)

		{

		User::Leave(KErrNotFound);

		}

	CleanupStack::PopAndDestroy(&plugins);

	}

EXPORT_C void CMMFDevVideoPlay::GetDecoderListL(RArray<TUid>& aDecoders)

	{

	RImplInfoPtrArray plugins;

	CleanupResetAndDestroyPushL(plugins);

	MmPluginUtils::FindImplementationsL(KUidDevVideoDecoderHwDevice, plugins);

	aDecoders.Reset();

	TInt count = plugins.Count();

	for (TInt i=0; i<count; i++)

		{

		User::LeaveIfError(aDecoders.Append(plugins[i]->ImplementationUid()));

		}

	CleanupStack::PopAndDestroy(&plugins);

	}

EXPORT_C void CMMFDevVideoPlay::GetPostProcessorListL(RArray<TUid>& aPostProcessors)

	{

	RImplInfoPtrArray plugins;

	CleanupResetAndDestroyPushL(plugins);

	MmPluginUtils::FindImplementationsL(KUidDevVideoPostProcessorHwDevice, plugins);

	aPostProcessors.Reset();

	TInt count = plugins.Count();

	for (TInt i=0; i<count; i++)

		{

		User::LeaveIfError(aPostProcessors.Append(plugins[i]->ImplementationUid()));

		}

	CleanupStack::PopAndDestroy(&plugins);

	}

EXPORT_C CVideoDecoderInfo* CMMFDevVideoPlay::VideoDecoderInfoLC(TUid aVideoDecoder)

	{

	CMMFVideoDecodeHwDevice* dev = CreateDecoderL(aVideoDecoder);

	CleanupStack::PushL(dev);

	CVideoDecoderInfo* info = dev->VideoDecoderInfoLC();

	CleanupStack::Pop(info);

	CleanupStack::PopAndDestroy(dev);

	CleanupStack::PushL(info);

	return info;

	}

EXPORT_C CPostProcessorInfo* CMMFDevVideoPlay::PostProcessorInfoLC(TUid aPostProcessor)

	{

	CMMFVideoPlayHwDevice* device = NULL;

	// Determine whether the aPostProcessor uid is for a decoder or a postprocessor hw device

	RArray<TUid> array;

	CleanupClosePushL(array);

	GetDecoderListL(array);

	TInt position = array.Find(aPostProcessor);

	if (position == KErrNotFound)

		{

		array.Reset();

		GetPostProcessorListL(array);

		position = array.Find(aPostProcessor);

		if (position != KErrNotFound)

			{

			// uid is a post processor

			device = static_cast<CMMFVideoPlayHwDevice*>(CMMFVideoPostProcHwDevice::NewL(aPostProcessor, *this));

			}

		}

	else

		{

		// uid is a decoder

		device = static_cast<CMMFVideoPlayHwDevice*>(CMMFVideoDecodeHwDevice::NewL(aPostProcessor, *this));

		}

	CleanupStack::PopAndDestroy(&array);

	CPostProcessorInfo* info = NULL;

	if (device)

		{

		CleanupStack::PushL(device);

		info = device->PostProcessorInfoLC();		

		CleanupStack::Pop(info);

		CleanupStack::PopAndDestroy(device);

		CleanupStack::PushL(info);

		}

	return info;

	}

EXPORT_C THwDeviceId CMMFDevVideoPlay::SelectDecoderL(TUid aDecoder)

	{

	// This method can only be called before InitializeL() has been called.

	CheckInitializationState(ENotInitialized);

	delete iVideoDecodeHwDevice;

	iVideoDecodeHwDevice = NULL;

#ifdef SYMBIAN_MULTIMEDIA_CODEC_API

	iVideoDecodeHwDevice = CreateDecoderL(aDecoder);

#else

	iVideoDecodeHwDevice = CMMFVideoDecodeHwDevice::NewL(aDecoder, *this);

#endif // SYMBIAN_MULTIMEDIA_CODEC_API

	return KHwDeviceIdVideoDecoder;

	}

EXPORT_C THwDeviceId CMMFDevVideoPlay::SelectPostProcessorL(TUid aPostProcessor)

	{

	// This method can only be called before InitializeL() has been called.

	CheckInitializationState(ENotInitialized);

	delete iVideoPostProcHwDevice;

	iVideoPostProcHwDevice = NULL;

	iVideoPostProcHwDevice = CMMFVideoPostProcHwDevice::NewL(aPostProcessor, *this);

	return KHwDeviceIdVideoPostProcessor;

	}

EXPORT_C TVideoPictureHeader* CMMFDevVideoPlay::GetHeaderInformationL(TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aDataUnitEncapsulation, TVideoInputBuffer* aDataUnit)

	{

	return VideoDecodeHwDevice().GetHeaderInformationL(aDataUnitType, aDataUnitEncapsulation, aDataUnit);

	}

/**

Configures the Decoder using header information known by the client.

@param	"aVideoPictureHeader"	"Header information to configure the decoder with"

@leave	"The method will leave if an error occurs. Running out of data is not considered an error, 

		as described above.

@pre	"This method can only be called before the API has been initialized with Initialize()."

*/

EXPORT_C void CMMFDevVideoPlay::ConfigureDecoderL(const TVideoPictureHeader& aVideoPictureHeader)

	{

	CheckInitializationState(ENotInitialized);

	VideoDecodeHwDevice().ConfigureDecoderL(aVideoPictureHeader);

	}

EXPORT_C void CMMFDevVideoPlay::ReturnHeader(TVideoPictureHeader* aHeader)

	{

	// This method can only be called before InitializeL()

	CheckInitializationState(ENotInitialized);

	VideoDecodeHwDevice().ReturnHeader(aHeader);

	}

EXPORT_C void CMMFDevVideoPlay::SetInputFormatL(THwDeviceId aHwDevice, const TUncompressedVideoFormat& aFormat)

	{

	CheckInitializationState(ENotInitialized);

	VideoPostProcHwDevice(aHwDevice).SetInputFormatL(aFormat);

	}

EXPORT_C void CMMFDevVideoPlay::SetInputFormatL(THwDeviceId aHwDevice, const CCompressedVideoFormat& aFormat, TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aEncapsulation, TBool aDataInOrder)

	{

	CheckInitializationState(ENotInitialized);

	VideoDecodeHwDevice(aHwDevice).SetInputFormatL(aFormat, aDataUnitType, aEncapsulation, aDataInOrder);

	}

EXPORT_C void CMMFDevVideoPlay::GetOutputFormatListL(THwDeviceId aHwDevice, RArray<TUncompressedVideoFormat>& aFormats)

	{

	CheckInitializationState(ENotInitialized);

	VideoPlayHwDevice(aHwDevice).GetOutputFormatListL(aFormats);

	}

EXPORT_C void CMMFDevVideoPlay::SetOutputFormatL(THwDeviceId aHwDevice, const TUncompressedVideoFormat &aFormat)

	{

	CheckInitializationState(ENotInitialized);

	VideoPlayHwDevice(aHwDevice).SetOutputFormatL(aFormat);

	}

EXPORT_C void CMMFDevVideoPlay::SetClockSource(MMMFClockSource* aClock)

	{

	CheckInitializationState(ENotInitialized);

	ASSERT(aClock);

	// Make sure we have at least one of the hwdevices set up

	__ASSERT_ALWAYS((iVideoDecodeHwDevice||iVideoPostProcHwDevice), DevVideoPanic(EDevVideoPanicPreConditionViolation));

	// Set the clock source on both hw devices.

	if (iVideoDecodeHwDevice)

		iVideoDecodeHwDevice->SetClockSource(aClock);

	if (iVideoPostProcHwDevice)

		iVideoPostProcHwDevice->SetClockSource(aClock);

	}

EXPORT_C void CMMFDevVideoPlay::SetVideoDestScreenL(TBool aScreen)

	{

	CheckInitializationState(ENotInitialized);

	// Pass on to the rendering hw device

	RenderingHwDevice().SetVideoDestScreenL(aScreen);

	}

EXPORT_C void CMMFDevVideoPlay::SynchronizeDecoding(TBool aSynchronize)

	{

	CheckInitializationState(ENotInitialized);

	VideoDecodeHwDevice().SynchronizeDecoding(aSynchronize);

	}

EXPORT_C void CMMFDevVideoPlay::SetBufferOptionsL(const TBufferOptions& aOptions)

	{

	CheckInitializationState(ENotInitialized);

	VideoDecodeHwDevice().SetBufferOptionsL(aOptions);

	}

EXPORT_C void CMMFDevVideoPlay::GetBufferOptions(TBufferOptions& aOptions)

	{

	CheckInitializationState(ENotInitialized);

	VideoDecodeHwDevice().GetBufferOptions(aOptions);

	}

EXPORT_C void CMMFDevVideoPlay::SetHrdVbvSpec(THrdVbvSpecification aHrdVbvSpec, const TDesC8& aHrdVbvParams)

	{

	CheckInitializationState(ENotInitialized);

	VideoDecodeHwDevice().SetHrdVbvSpec(aHrdVbvSpec, aHrdVbvParams);

	}

EXPORT_C void CMMFDevVideoPlay::SetPostProcessTypesL(THwDeviceId aHwDevice, TUint32 aPostProcCombination)

	{

	CheckInitializationState(ENotInitialized|EInitialized);

	VideoPlayHwDevice(aHwDevice).SetPostProcessTypesL(aPostProcCombination);

	}

EXPORT_C void CMMFDevVideoPlay::SetInputCropOptionsL(THwDeviceId aHwDevice, const TRect& aRect)

	{

	CheckInitializationState(ENotInitialized|EInitialized);

	VideoPlayHwDevice(aHwDevice).SetInputCropOptionsL(aRect);	

	}

EXPORT_C void CMMFDevVideoPlay::SetYuvToRgbOptionsL(THwDeviceId aHwDevice, const TYuvToRgbOptions& aOptions, const TYuvFormat& aYuvFormat, TRgbFormat aRgbFormat)

	{

	CheckInitializationState(ENotInitialized|EInitialized);