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

// Audio, MIDI and Video client utility functions.

// 

//

#include <e32std.h>

#include <f32file.h>

#include <bautils.h>

#include <mmf/server/mmfdrmpluginserverproxy.h>

#include <caf/content.h>

#include <caf/data.h>

using namespace ContentAccess;

#include "mmfclientutility.h"

#include <mmf/common/mmfpaniccodes.h>

const TInt KMaxMimeLength = 256;

const TInt KMaxHeaderSize = 256;

const TInt KExpandSize = 100;

#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

	const TInt KDefaultScreenNo = 0;

#endif

void CUPanic(TInt aCUPanicCode)

	{

	_LIT(KMMFMediaClientUtilityPaanicCategory, "MMFClientUtility");

	User::Panic(KMMFMediaClientUtilityPaanicCategory, aCUPanicCode);

	}

/**

 * @internalComponent

 */

EXPORT_C TUid CMMFClientUtility::ConvertMdaFormatUidToECOMWrite(TUid aMdaFormatUid)

	{

	TUid ECOMUid = KNullUid;

	if (aMdaFormatUid == KUidMdaClipFormatWav)	

		ECOMUid = TUid::Uid(KMmfUidFormatWAVWrite);

	else if (aMdaFormatUid == KUidMdaClipFormatAu)	

		ECOMUid = TUid::Uid(KMmfUidFormatAUWrite);

	else if (aMdaFormatUid == KUidMdaClipFormatRawAudio)	

		ECOMUid = TUid::Uid(KMmfUidFormatRAWWrite);

	else if (aMdaFormatUid == KUidMdaClipFormatRawAmr)	

		ECOMUid = TUid::Uid(KAdvancedUidFormatAMRWrite);

	return ECOMUid;

	}

/**

 * @internalComponent

 */

EXPORT_C TUid CMMFClientUtility::ConvertMdaFormatUidToECOMRead(TUid aMdaFormatUid)

	{

	TUid ECOMUid = KNullUid;

	if (aMdaFormatUid == KUidMdaClipFormatWav)	

		ECOMUid = TUid::Uid(KMmfUidFormatWAVRead);

	else if (aMdaFormatUid == KUidMdaClipFormatAu)	

		ECOMUid = TUid::Uid(KMmfUidFormatAURead);

	else if (aMdaFormatUid == KUidMdaClipFormatRawAudio)	

		ECOMUid = TUid::Uid(KMmfUidFormatRAWRead);

	else if (aMdaFormatUid == KUidMdaClipFormatRawAmr)	

		ECOMUid = TUid::Uid(KAdvancedUidFormatAMRRead);

	return ECOMUid;

	}

/**

 * @internalComponent

 */

EXPORT_C TInt CMMFClientUtility::GetFileHeaderData(const TDesC& aFileName, TDes8& aHeaderData, TInt aMaxLength)

	{

	RFs fsSession;

	RFile file;

	TInt error = KErrNone;

	if ((error = fsSession.Connect()) == KErrNone)

		{

		if ((error = file.Open(fsSession, aFileName, EFileShareReadersOrWriters)) == KErrNone)

			{

			TInt size = 0;

			if ((error = file.Size(size)) == KErrNone)

				{

				if (size > 0)

					{

					if (size > aMaxLength) 

						size = aMaxLength;

					error = file.Read(aHeaderData, size);

					}

				}

			file.Close();

			}

		fsSession.Close();

		}

	return error;

	}

/**

 * @internalComponent

 */

EXPORT_C TFourCC CMMFClientUtility::ConvertMdaCodecToFourCC(TMdaPackage& aCodec)

	{

	TFourCC dataType = KMMFFourCCCodeNULL;	

	switch (aCodec.Uid().iUid)

		{

		case KUidMdaWavPcmCodecDefine: 

			{

			TMdaPcmWavCodec* pcmWavCodec = (TMdaPcmWavCodec*)&aCodec;

			if (pcmWavCodec->iBits == TMdaPcmWavCodec::E8BitPcm)

				dataType = KMMFFourCCCodePCMU8; //8 bit PCM

			else 

				dataType = KMMFFourCCCodePCM16; //16 bit PCM

			break;

			}

		case KUidMdaAu8PcmCodecDefine:

			dataType = KMMFFourCCCodePCM8;

			break;

		case KUidMdaAuCodecDefine:

		case KUidMdaAu16PcmCodecDefine:

			dataType = KMMFFourCCCodePCM16B;

			break;

		case KUidMdaAuMulawCodecDefine:

		case KUidMdaWavMulawCodecDefine:

		case KUidMdaRawAudioMulawCodecDefine:  //uLAW

			dataType = KMMFFourCCCodeMuLAW;

			break;

		case KUidMdaAuAlawCodecDefine:

		case KUidMdaWavAlawCodecDefine:

		case KUidMdaRawAudioAlawCodecDefine:	 //ALAW

			dataType = KMMFFourCCCodeALAW;

			break;

		case KUidMdaRawAudioS8PcmCodecDefine:	 //  P8

			dataType = KMMFFourCCCodePCM8;

			break;

		case KUidMdaRawAudioU8PcmCodecDefine:	  // PU8

			dataType = KMMFFourCCCodePCMU8;

			break;

		case KUidMdaRawAudioSL16PcmCodecDefine: // P16

			dataType = KMMFFourCCCodePCM16;

			break;

		case KUidMdaRawAudioSB16PcmCodecDefine: //P16B

			dataType = KMMFFourCCCodePCM16B;

			break;

		case KUidMdaRawAudioUL16PcmCodecDefine: //PU16

			dataType = KMMFFourCCCodePCMU16;

			break;

		case KUidMdaRawAudioUB16PcmCodecDefine: //PU6B

			dataType = KMMFFourCCCodePCMU16B; 

			break;

		case KUidMdaGsmWavCodecDefine: //GSM6 

			dataType = KMMFFourCCCodeGSM610;

			break;

		case KUidMdaWavImaAdpcmCodecDefine:

			dataType = KMMFFourCCCodeIMAD;

			break;

		case KUidMdaRawAmrCodecDefine:

			dataType = KMMFFourCCCodeAMR;

			break;

		default:	// Not a Uid we recognise

			dataType = KMMFFourCCCodeNULL;

			break;

		}

	return dataType;

	}

CMMFUtilityFileInfo* CMMFUtilityFileInfo::NewL(TMMSource& aSource, TBool aSecureDRMMode)

	{

	CMMFUtilityFileInfo* self = CMMFUtilityFileInfo::NewLC(aSource, aSecureDRMMode);

	CleanupStack::Pop(self);

	return self;

	}

CMMFUtilityFileInfo* CMMFUtilityFileInfo::NewLC(TMMSource& aSource, TBool aSecureDRMMode)

	{

	CMMFUtilityFileInfo* self = new (ELeave) CMMFUtilityFileInfo;

	CleanupStack::PushL(self);

	self->ConstructL(aSource, aSecureDRMMode);

	return self;

	}

void CMMFUtilityFileInfo::ConstructL(const TMMSource& aSource, TBool aSecureDRMMode)

	{

	if (!aSecureDRMMode)

		{

		if (aSource.SourceType()==KUidMMFileSource)

			{

			const TMMFileSource& fileSource = static_cast<const TMMFileSource&>(aSource);

			iData = CData::NewL(TVirtualPathPtr(fileSource.Name(), fileSource.UniqueId()),

								EContentShareReadWrite);

			}

		if (aSource.SourceType()==KUidMMFileHandleSource)

			{

			const TMMFileHandleSource& fileHandleSource = static_cast<const TMMFileHandleSource&>(aSource);

			iData = CData::NewL(fileHandleSource.Handle(), fileHandleSource.UniqueId());

			}

		TInt err = iData->SetProperty(EAgentPropertyAgentUI, aSource.IsUIEnabled());		

		if (err != KErrNone && err != KErrCANotSupported)

			{

			// KErrCANotSupported isn't a problem for us so eat the error code.

			User::Leave(err);

			}

		err = iData->EvaluateIntent(aSource.Intent());

		User::LeaveIfError(err);

		}

	else

		{

		// Use RMMFDRMPluginServerProxy as medium

		iDrmPluginServer = new (ELeave) RMMFDRMPluginServerProxy;

		User::LeaveIfError(iDrmPluginServer->Open());

		CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);

		CleanupStack::PushL(dataBuffer);

		RBufWriteStream stream;

		stream.Open(*dataBuffer);

		CleanupClosePushL(stream);

		stream.WriteInt32L(aSource.UniqueId().Length());

		stream.WriteL(aSource.UniqueId());

		stream.WriteInt32L(aSource.IsUIEnabled());

		TPckgBuf<ContentAccess::TIntent> intentPckg(aSource.Intent());

		stream.WriteL(intentPckg);

		stream.CommitL();

		CleanupStack::PopAndDestroy(&stream);

		if (aSource.SourceType()==KUidMMFileSource)

			{

			const TMMFileSource& fileSource = static_cast<const TMMFileSource&>(aSource);

			iDrmPluginServer->OpenDataContentL(fileSource.Name(), dataBuffer->Ptr(0));

			}

		if (aSource.SourceType()==KUidMMFileHandleSource)

			{

			const TMMFileHandleSource& fileHandleSource = static_cast<const TMMFileHandleSource&>(aSource);

			iDrmPluginServer->OpenDataContentL(fileHandleSource.Handle(), dataBuffer->Ptr(0));

			}

		CleanupStack::PopAndDestroy(dataBuffer);

		}

	}

TInt CMMFUtilityFileInfo::EvaluateIntent(TIntent aIntent)

	{

	if (iData)

		{

		return iData->EvaluateIntent(aIntent);

		}

	else

		{

		ASSERT(iDrmPluginServer);

		return iDrmPluginServer->EvaluateDataContentIntent(aIntent);

		}

	}

/**

 * @internalComponent

 */

TBool CMMFUtilityFileInfo::GetFileMimeTypeL(TDes8& aMimeType)

	{

	if (iData)

		{

		return iData->GetMimeTypeL(aMimeType);

		}

	else

		{

		ASSERT(iDrmPluginServer);

		return iDrmPluginServer->GetDataContentMimeTypeL(aMimeType);

		}

	}

/**

 * @internalComponent

 */

void CMMFUtilityFileInfo::GetFileHeaderDataL(TDes8& aHeaderData, TInt aMaxLength)

	{

	if (iData)

		{

		TInt size = 0;

		iData->DataSizeL(size);

		if (size > 0)

			{

			if (size > aMaxLength) 

				size = aMaxLength;

			TInt pos = 0;

			User::LeaveIfError(iData->Seek(ESeekStart, pos));

			User::LeaveIfError(iData->Read(aHeaderData, size));

			}

		}

	else

		{

		ASSERT(iDrmPluginServer);

		iDrmPluginServer->GetDataContentFileHeaderL(aHeaderData, aMaxLength);

		}

	}

/**

 * @internalComponent

 */

EXPORT_C HBufC8* CMMFClientUtility::GetFileExtensionL(const TDesC& aFileName)

	{

	TParse fileName;

	fileName.Set(aFileName,NULL,NULL);

	HBufC8* fileSuffix = NULL;

	if(fileName.ExtPresent())

		{

		TPtrC fileSuffixPtr(fileName.Ext());

		fileSuffix = HBufC8::NewL(fileSuffixPtr.Length());

		fileSuffix->Des().Copy(fileSuffixPtr);

		}

	else

		{

		fileSuffix = KNullDesC8().AllocL();

		}

	return fileSuffix;

	}

/**

 * @internalComponent

 */

CMMFUtilityFileInfo::~CMMFUtilityFileInfo()

	{

	if (iData)

		{

		delete iData;

		}

	if (iDrmPluginServer)

		{

		iDrmPluginServer->Close();

		delete iDrmPluginServer;

		}

	}

/*

 * @internalComponent

 *

 * Returns an integer rating indicating how well the supplied format matches

 * the header data and file extension supplied.

 * 3 brownie points awarded for data & suffix match.

 * 2 brownie points awarded for data match alone.

 * 1 brownie point awarded for suffix match alone.

 */

TInt CMMFClientUtility::GetBestMatchL(const CMMFFormatImplementationInformation* format, const TDesC8& aHeaderData, const TDesC8& aFileExtension)

	{

	TInt browniePoints = 0;

	if (aHeaderData.Length() > 0) // Non empty file

		{

		if (aFileExtension.Length() > 0) // With a file extension

			{

			if (format->SupportsHeaderDataL(aHeaderData) && 

				format->SupportsFileExtension(aFileExtension))

				{

				browniePoints = 3;

				}

			else if (format->SupportsHeaderDataL(aHeaderData))

				{

				browniePoints = 2;

				}

			else

				{

				// See if this format has any 'empty' match data or no match data, indicating 

				// that this format will match extension alone even if data present.

				// (A format may have more than one match data string.)

				const CDesC8Array& supportedHeaderData = format->SupportedHeaderData();

				if (supportedHeaderData.Count() == 0)

					{

					// No header data indicated.

					if (format->SupportsFileExtension(aFileExtension))

						{

							browniePoints = 1;

						}

					}

				else

					{

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

						{

						if ((supportedHeaderData[i].Length() == 0) && 

							format->SupportsFileExtension(aFileExtension))

							{

							browniePoints = 1;

							}

						}

					}

				}

			}

		else

			{

			// No file suffix, so must match header data alone.

			if (format->SupportsHeaderDataL(aHeaderData))

				{

				browniePoints = 2;

				}

			}

		}

	else // Empty File

		{

		// We have no choice but to match extension, if there is one.

		if ((aFileExtension.Length() > 0) && format->SupportsFileExtension(aFileExtension))

			{

			browniePoints = 1;

			}

		}

	return browniePoints;

}

/**

 * @internalComponent

 *

 * This function parses all the play & record formats in the given list of controllers,

 * looking for controllers & formats that best match the requirements. 

 * Play controllers will be returned before record controllers, and

 * in cases of equal priority between formats, ECom order will be maintained.

 *

 * @param	"aControllers"	

 *			A reference to a user supplied list of controllers retrieved from ECom.

 *			This list may be have been filtered for audio/video/play/record.

 * @param	"aHeaderDataPlayback"

 *			A descriptor reference containing the file's header data.

 *          for matching against a controller's play formats. May be KNullDesC8

 * @param	"aFileExtensionPlayback"

 *			A descriptor reference containing the filename's extension.

 *          for matching against a controller's play formats. May be KNullDesC8

 * @param	"aHeaderDataRecord"

 *			A descriptor reference containing the file's header data.

 *          for matching against a controller's record formats. May be KNullDesC8

 * @param	"aFileExtensionRecord"

 *			A descriptor reference containing the filename's extension.

 *          for matching against a controller's record formats. May be KNullDesC8

 * @param	"aPrioritisedControllers"

 *			A reference to a user supplied list through which the list of

 *			prioritised controllers will be returned.

 * @since	7.0s

 */

void CMMFClientUtility::PrioritiseControllersL(

	const RMMFControllerImplInfoArray& aControllers, 

	const TDesC8& aHeaderDataPlayback, 

	const TDesC8& aFileExtensionPlayback, 

	const TDesC8& aHeaderDataRecord, 

	const TDesC8& aFileExtensionRecord, 

	RMMFControllerImplInfoArray& prioritisedControllers)

	{

	RMMFControllerImplInfoArray fullMatchControllers; // data AND suffix

	CleanupClosePushL(fullMatchControllers);

	RMMFControllerImplInfoArray partMatchControllers; // data OR suffix

	CleanupClosePushL(partMatchControllers);

	TBool checkingPlaybackFormats = EFalse;

	TBool checkingRecordFormats = EFalse;

	if (aHeaderDataPlayback != KNullDesC8 || aFileExtensionPlayback != KNullDesC8)

		checkingPlaybackFormats = ETrue;

	if (aHeaderDataRecord != KNullDesC8 || aFileExtensionRecord != KNullDesC8)

		checkingRecordFormats = ETrue;

	// Examine each format for each controller. We only want to know at this stage

	// if the controller has suitable formats, so as soon as we know it has, we can

	// add it to out list, ranked by how well it matched.

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

		{

		const CMMFControllerImplementationInformation* controller = aControllers[i];

		TInt savedBrowniePointsPlayback = 0;

		TInt savedBrowniePointsRecord = 0;

		if (checkingPlaybackFormats)

			{

			for (register TInt p = 0; p < controller->PlayFormats().Count(); p++)

				{

				const CMMFFormatImplementationInformation* format = controller->PlayFormats()[p];

				TInt browniePoints = GetBestMatchL(format, aHeaderDataPlayback, aFileExtensionPlayback);

				if (browniePoints >= savedBrowniePointsPlayback)

					savedBrowniePointsPlayback = browniePoints;

				}

			}

		if (checkingRecordFormats)

			{

			for (register TInt r = 0; r < controller->RecordFormats().Count(); r++)

				{

				const CMMFFormatImplementationInformation* format = controller->RecordFormats()[r];

				TInt browniePoints = GetBestMatchL(format, aHeaderDataRecord, aFileExtensionRecord);

				if (browniePoints >= savedBrowniePointsRecord)

					savedBrowniePointsRecord = browniePoints;

				}

			}

		TInt savedBrowniePoints = 0;

		// if we're checking both playback & record formats

		// make sure we've found both

		if (checkingPlaybackFormats && checkingRecordFormats)

			{

			savedBrowniePoints = Min(savedBrowniePointsPlayback, savedBrowniePointsRecord);

			}

		else if (checkingPlaybackFormats)

			{

			savedBrowniePoints = savedBrowniePointsPlayback;

			}

		else if (checkingRecordFormats)

			{

			savedBrowniePoints = savedBrowniePointsRecord;

			}

		// Checked all formats for this controller, now count our brownie points.

		switch (savedBrowniePoints)

			{