// 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

	{