/*

* Copyright (c) 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:  Definition of the ClientUtility class.

*

*/

//

// Copyright (c) Symbian Software Ltd 2002-2006.  All rights reserved.

//

// Audio, MIDI and Video client utility functions.

#include "ClientUtility.h"

#include <e32std.h>

#include <bautils.h>

#include <mmf/common/mmfpaniccodes.h>

#include <StreamControlCustomCommands.h>

#include <mmf/server/mmfdrmpluginserverproxy.h>

#include "../../../Plugins/FileSource/inc/FileDataSourceUid.hrh"

using namespace ContentAccess;

using namespace multimedia;

const TInt KMaxMimeLength = 256;

const TInt KMaxHeaderSize = 256;

const TInt KExpandSize = 100;

void CUPanic(TInt aCUPanicCode)

    {

    _LIT(KMMFMediaClientUtilityPaanicCategory, "EnhancedAudioClient");

    User::Panic(KMMFMediaClientUtilityPaanicCategory, aCUPanicCode);

    }

    /**

    * @internalComponent

*/

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

*/

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

*/

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

*/

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

*/

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) &&*/  //Shubham

                            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.