/*

* Copyright (c) 2005-2006 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 <caf/caf.h>

#include <caf/content.h>

#include <caf/data.h>

using namespace ContentAccess;

#include "S60AudioUtility.h"

#include <mmf/common/mmfpaniccodes.h>

const TInt KMaxMimeLength = 256;

const TInt KMaxHeaderSize = 256;

void CUPanic(TInt aCUPanicCode)

	{

	_LIT(KMMFMediaClientUtilityPaanicCategory, "S60AudioUtility");

	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, EFileShareReadersOnly)) == 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)

	{

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

	CleanupStack::Pop(self);

	return self;

	}

CMMFUtilityFileInfo* CMMFUtilityFileInfo::NewLC(TMMSource& aSource)

	{

	CMMFUtilityFileInfo* self = new (ELeave) CMMFUtilityFileInfo;

	CleanupStack::PushL(self);

	self->ConstructL(aSource);

	return self;

	}

void CMMFUtilityFileInfo::ConstructL(const TMMSource& aSource)

	{

	if (aSource.SourceType()==KUidMMFileSource)

		{

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

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

							EContentShareReadOnly);

		}

	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);

	}

TInt CMMFUtilityFileInfo::EvaluateIntent(TIntent aIntent)

	{

	return iData->EvaluateIntent(aIntent);

	}

/**

 * @internalComponent

 */

TBool CMMFUtilityFileInfo::GetFileMimeTypeL(TDes8& aMimeType)

	{

	return iData->GetMimeTypeL(aMimeType);

	}

/**

 * @internalComponent

 */

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

	{

	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));

		}

	}

/**

 * @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()

	{

	delete iData;

	}

/*

 * @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

 * @lib	"MediaClientUtility.lib"

 */

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)

			{

			case 3:

				User::LeaveIfError(fullMatchControllers.Append(controller));

				break;

			case 2:

				User::LeaveIfError(partMatchControllers.Insert(controller, 0));

				break;

			case 1:

				User::LeaveIfError(partMatchControllers.Append(controller));

				break;

			default:

				break;

			}

		}

	// The better the controller matches, the earlier it will be in the final list.

	for (register TInt x = 0; x < fullMatchControllers.Count(); x++)

		{

		if (prioritisedControllers.Find(fullMatchControllers[x]) == KErrNotFound)

			{

			User::LeaveIfError(prioritisedControllers.Append(fullMatchControllers[x]));

			}

		}

	for (register TInt y = 0; y < partMatchControllers.Count(); y++)

		{

		if (prioritisedControllers.Find(partMatchControllers[y]) == KErrNotFound)

			{

			User::LeaveIfError(prioritisedControllers.Append(partMatchControllers[y]));

			}

		}

	CleanupStack::PopAndDestroy(2, &fullMatchControllers); // fullMatchControllers, partMatchControllers

	}

/**

 * @internalComponent

 */

EXPORT_C CMMFMdaObjectStateChangeObserverCallback* CMMFMdaObjectStateChangeObserverCallback::NewL(MMdaObjectStateChangeObserver& aCallback)

	{

	return new(ELeave) CMMFMdaObjectStateChangeObserverCallback(aCallback);

	}

/**

 * @internalComponent

 */

CMMFMdaObjectStateChangeObserverCallback::~CMMFMdaObjectStateChangeObserverCallback()

	{

	Cancel();

	}

/**

 * @internalComponent

 */

EXPORT_C void CMMFMdaObjectStateChangeObserverCallback::CallBack(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

	{

	iObject = aObject;

	iPreviousState = aPreviousState;

	iCurrentState = aCurrentState;

	iErrorCode = aErrorCode;

	if (!IsActive())

		{

		TRequestStatus* s = &iStatus;

		SetActive();

		User::RequestComplete(s, KErrNone);

		}

	}

CMMFMdaObjectStateChangeObserverCallback::CMMFMdaObjectStateChangeObserverCallback(MMdaObjectStateChangeObserver& aCallback) :