/*
* 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:   Message handler for WMA 10 Pro decoder custom interface.
*
*/



// INCLUDE FILES
#include    "WmaDecoderIntfcMsgs.h"
#include    "WmaDecoderIntfcMsgHdlr.h"
//#include "WmaDecoderIntfc.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::CWmaDecoderIntfcMsgHdlr
// C++ default constructor can NOT contain any code, that might leave.
//------------------------------------------------------------------------------
CWmaDecoderIntfcMsgHdlr::CWmaDecoderIntfcMsgHdlr(
                              CWmaDecoderIntfc* aWmaDecoderConfigCI) :
	CMMFObject(KUidWmaDecoderIntfc)
    {
    iWmaDecoderIntfcCI = aWmaDecoderConfigCI;
    }

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::ConstructL
// Symbian 2nd phase constructor can leave.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::ConstructL()
    {
    }

//------------------------------------------------------------------------------
// WmaDecoderIntfcMsgHdlr::NewL
// Two-phased constructor.
//------------------------------------------------------------------------------
EXPORT_C CWmaDecoderIntfcMsgHdlr* CWmaDecoderIntfcMsgHdlr::NewL(
                                       TAny* aWmaDecoderConfigCI)
    {
    CWmaDecoderIntfc* WmaDecoderConfigCI =
                (CWmaDecoderIntfc*)aWmaDecoderConfigCI;
    CWmaDecoderIntfcMsgHdlr* self =
                new (ELeave) CWmaDecoderIntfcMsgHdlr(WmaDecoderConfigCI);
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

//------------------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------------------
EXPORT_C CWmaDecoderIntfcMsgHdlr::~CWmaDecoderIntfcMsgHdlr()
	{
    iSupportedFormats.Close();
    iSupportedTools.Close();
    iControllableTools.Close();

	delete iDataCopyBuffer;
	delete iWmaDecoderIntfcCI;
	}

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::HandleRequest
// Handles the messages from the proxy.
//------------------------------------------------------------------------------ 
EXPORT_C void CWmaDecoderIntfcMsgHdlr::HandleRequest(
                                            TMMFMessage& aMessage)
	{
	ASSERT(aMessage.Destination().InterfaceId() == KUidWmaDecoderIntfc);

	TRAPD(error, DoHandleRequestL(aMessage));

	if(error)
		{
		aMessage.Complete(error);
		}
	}

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoHandleRequestL
// Determines which custom interface to call.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::DoHandleRequestL(TMMFMessage& aMessage)
	{
	switch(aMessage.Function())
		{
		case EWmaGetSupportedFormats:
			{
    		DoGetSupportedFormatsL(aMessage);
			break;
			}
		case EWmaGetSupportedTools:
			{
    		DoGetSupportedToolsL(aMessage);
			break;
			}
		case EWmaGetSupportedMaxChannels:
			{
    		DoGetSupportedMaxChannelsL(aMessage);
			break;
			}
		case EWmaGetSupportedMaxBitrate:
			{
    		DoGetSupportedMaxBitrateL(aMessage);
			break;
			}
		case EWmaGetSupportedMaxSampleRate:
			{
    		DoGetSupportedMaxSampleRateL(aMessage);
			break;
			}
		case EWmaGetControllableTools:
			{
    		DoGetControllableToolsL(aMessage);
			break;
			}
		case EWmaGetAllMsg:
			{
    		DoGetAllL(aMessage);
			break;
			}		
		case EWmaApplyConfig:
			{
    		DoApplyConfigL(aMessage);
			break;
			}
		case EWmaGetNumOfSupportedFormats:
 			{
    		DoGetNumOfSupportedFormatsL(aMessage);
			break;
			}
   		case EWmaGetNumOfSupportedTools:
			{
    		DoGetNumOfSupportedToolsL(aMessage);
			break;
			}		
		case EWmaGetNumOfControllableTools:
   			{
    		DoGetNumOfControllableToolsL(aMessage);
			break;
			}
 
		default:
			{
			aMessage.Complete(KErrNotSupported);
			break;
			}
		}
	}

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetSupportedFormatsL
// Get supported formats.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::DoGetSupportedFormatsL(TMMFMessage& aMessage)
	{
	if (!iDataCopyBuffer)
		{
		User::Leave(KErrNotReady);			
		}
	aMessage.WriteDataToClientL(iDataCopyBuffer->Ptr(0));
    aMessage.Complete(KErrNone);
    }

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetSupportedToolsL
// Get supported tools.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::DoGetSupportedToolsL(TMMFMessage& aMessage)
	{
	if (!iDataCopyBuffer)
		{
		User::Leave(KErrNotReady);			
		}
	aMessage.WriteDataToClientL(iDataCopyBuffer->Ptr(0));
    aMessage.Complete(KErrNone);
	}
	
//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetSupportedMaxChannelsL
// Get max number of channels.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::DoGetSupportedMaxChannelsL(TMMFMessage& aMessage)
	{
	TUint maxChannels = 0;
	TInt status = iWmaDecoderIntfcCI->GetSupportedMaxChannelsIn(maxChannels);

    TPckgBuf<TUint> pckg;
    pckg() = maxChannels;
	aMessage.WriteDataToClientL(pckg);
    	
    aMessage.Complete(status);		
	}

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetSupportedMaxBitrateL
// Get supported max bit rates.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::DoGetSupportedMaxBitrateL(TMMFMessage& aMessage)
	{
	TUint maxBitrate = 0;
	TInt status = iWmaDecoderIntfcCI->GetSupportedMaxBitrate(maxBitrate);

   	TPckgBuf<TUint> pckg;
   	pckg() = maxBitrate;
    aMessage.WriteDataToClientL(pckg);
   
    aMessage.Complete(status);			
	}

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetSupportedMaxSampleRateL
// Get supported max sample rate.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::DoGetSupportedMaxSampleRateL(TMMFMessage& aMessage)
	{
	TUint maxSamplerate = 0;
	TInt status = iWmaDecoderIntfcCI->GetSupportedMaxSampleRate(maxSamplerate);

    TPckgBuf<TUint> pckg;
    pckg() = maxSamplerate;
	aMessage.WriteDataToClientL(pckg);
    
    aMessage.Complete(status);		
		
	}

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetControllableToolsL
// Get supported controllable tools.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::DoGetControllableToolsL(TMMFMessage& aMessage)
	{
	if (!iDataCopyBuffer)
		{
		User::Leave(KErrNotReady);			
		}
	aMessage.WriteDataToClientL(iDataCopyBuffer->Ptr(0));
    aMessage.Complete(KErrNone);
	}

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetAllL
// Get all configure parameters.
//------------------------------------------------------------------------------	
void CWmaDecoderIntfcMsgHdlr::DoGetAllL(TMMFMessage& aMessage)
	{
   	TPckgBuf<TAllParams> pckg;
	CWmaDecoderIntfc::TFormat format;
	TInt status = iWmaDecoderIntfcCI->GetFormat(format);
   	pckg().iCurrentFormat = format;
	pckg().iCurrentFormatStatus = status;    	

    TUint bitsPerSample = 0;
    status = iWmaDecoderIntfcCI->GetBitsPerSampleIn(bitsPerSample);    	
    pckg().iCurrentBitsPerSample = bitsPerSample;
	pckg().iCurrentBitsPerSampleStatus = status;    	

	TUint numOfChannels = 0;
	status = iWmaDecoderIntfcCI->GetNumOfChannelsIn(numOfChannels);
   	pckg().iCurrentNumChannelsIn = numOfChannels;
	pckg().iCurrentNumChannelsInStatus = status;    	

	TUint samplesPerSec = 0;
	status = iWmaDecoderIntfcCI->GetSamplesPerSec (samplesPerSec);
   	pckg().iCurrentSamplesPerSec = samplesPerSec;
	pckg().iCurrentSamplesPerSecStatus = status;    	

    TUint avgBytesPerSec = 0;
    status = iWmaDecoderIntfcCI->GetAvgBytesPerSec (avgBytesPerSec);
   	pckg().iCurrentAvgBytesPerSec = avgBytesPerSec;
	pckg().iCurrentAvgBytesPerSecStatus = status;    	

	TUint blockAlign = 0;
	status = iWmaDecoderIntfcCI->GetBlockAlign (blockAlign) ;
   	pckg().iCurrentBlockAlign = blockAlign;
	pckg().iCurrentBlockAlignStatus = status;    	

	TUint encodeOpts = 0;
	status = iWmaDecoderIntfcCI->GetEncodeOptions (encodeOpts);
   	pckg().iCurrentEncodeOptions = encodeOpts;
	pckg().iCurrentEncodeOptionsStatus = status;    	

	TUint encodeOpts1 = 0;
	status = iWmaDecoderIntfcCI->GetEncodeOptions1 (encodeOpts1);
   	pckg().iCurrentEncodeOptions1 = encodeOpts1;
	pckg().iCurrentEncodeOptions1Status = status;    
		
	TUint encodeOpts2 = 0;
	status = iWmaDecoderIntfcCI->GetEncodeOptions2(encodeOpts2);
   	pckg().iCurrentEncodeOptions2 = encodeOpts2;
	pckg().iCurrentEncodeOptions2Status = status;    	
   	
	TUint channelMask = 0;
	status = iWmaDecoderIntfcCI->GetChannelMaskIn (channelMask);
   	pckg().iCurrentChannelMask = channelMask;
	pckg().iCurrentChannelMaskStatus = status;    	
   	
	CWmaDecoderIntfc::TTool tool = CWmaDecoderIntfc::EToolOutput32Bit;
	TBool able = EFalse;
	status = iWmaDecoderIntfcCI->GetTool(tool, able);
   	pckg().iCurrentToolOutPut32Bit = able;
	pckg().iCurrentToolOutPut32BitStatus = status;    	
   	
	tool = CWmaDecoderIntfc::EDownMixToStereo;
	status = iWmaDecoderIntfcCI->GetTool(tool, able);
   	pckg().iCurrentToolDownMixToStereo = able;
	pckg().iCurrentToolDownMixToStereoStatus = status;    	
	   	
	tool = CWmaDecoderIntfc::ELostDataConcealment;
	status = iWmaDecoderIntfcCI->GetTool(tool, able);
   	pckg().iCurrentToolLostDataConcealment = able;
	pckg().iCurrentToolLostDataConcealmentStatus = status;    	
 
    aMessage.WriteDataToClientL(pckg);
    
    aMessage.Complete(KErrNone);
	}


//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoApplyConfigL
// Handles the message from the proxy and calls the custom interface method
// to commit configuration settings to the decoder.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::DoApplyConfigL(TMMFMessage& aMessage)
    {
    TInt status = KErrNone;
	TPckgBuf<TWmaDecoderConfig> pckgBuf;
	
    aMessage.ReadData1FromClientL(pckgBuf);
	
	iWmaDecoderIntfcCI->SetFormat(pckgBuf().iFormat);
	iWmaDecoderIntfcCI->SetBitsPerSampleIn(pckgBuf().iBitsPerSample);
	iWmaDecoderIntfcCI->SetNumChannelsIn(pckgBuf().iNumChannelsIn);
	iWmaDecoderIntfcCI->SetSamplesPerSec(pckgBuf().iSamplesPerSec);
	iWmaDecoderIntfcCI->SetAvgBytesPerSec(pckgBuf().iAvgBytesPerSec);
	iWmaDecoderIntfcCI->SetBlockAlign(pckgBuf().iBlockAlign);
	iWmaDecoderIntfcCI->SetEncodeOptions(pckgBuf().iEncodeOptions);
	iWmaDecoderIntfcCI->SetEncodeOptions1(pckgBuf().iEncodeOptions1);
	iWmaDecoderIntfcCI->SetEncodeOptions2(pckgBuf().iEncodeOptions2);				
	iWmaDecoderIntfcCI->SetChannelMaskIn(pckgBuf().iChannelMask);

    TBool able = pckgBuf().iToolOutPut32Bit;
    if (able)
    	{
    	iWmaDecoderIntfcCI->EnableTool(CWmaDecoderIntfc::EToolOutput32Bit);	
    	}
    else
    	{
    	iWmaDecoderIntfcCI->DisableTool(CWmaDecoderIntfc::EToolOutput32Bit);	
    	}

    able = pckgBuf().iToolDownMixToStereo;
    if (able)
    	{
    	iWmaDecoderIntfcCI->EnableTool(CWmaDecoderIntfc::EDownMixToStereo);	
    	}
    else
    	{
    	iWmaDecoderIntfcCI->DisableTool(CWmaDecoderIntfc::EDownMixToStereo);	
    	}

    able = pckgBuf().iToolLostDataConcealment;
    if (able)
    	{
    	iWmaDecoderIntfcCI->EnableTool(CWmaDecoderIntfc::ELostDataConcealment);	
    	}
    else
    	{
    	iWmaDecoderIntfcCI->DisableTool(CWmaDecoderIntfc::ELostDataConcealment);	
    	}

	status = iWmaDecoderIntfcCI->ApplyConfig();
    aMessage.Complete(status);
    }

//------------------------------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::CreateBufFromUintArrayL
// Utility function used to create a buffer and fill it with data from the
// array passed in.
//------------------------------------------------------------------------------
void CWmaDecoderIntfcMsgHdlr::CreateBufFromUintArrayL(RArray<TUint>& aArray)
	{
	delete iDataCopyBuffer;
	iDataCopyBuffer = NULL;
	iDataCopyBuffer = CBufFlat::NewL(8);

	RBufWriteStream stream;
	stream.Open(*iDataCopyBuffer);
	CleanupClosePushL(stream);

	for (TInt i = 0; i < aArray.Count(); i++)
	    {	    	    
		stream.WriteUint32L(aArray[i]);
	    }
	    
	CleanupStack::PopAndDestroy(&stream);
	}	

// ---------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetNumOfSupportedFormatsL
//
// ---------------------------------------------------------
//
void CWmaDecoderIntfcMsgHdlr::DoGetNumOfSupportedFormatsL(TMMFMessage& aMessage)
	{
	iSupportedFormats.Reset();
	TInt status = iWmaDecoderIntfcCI->GetSupportedFormats(iSupportedFormats);

	CreateBufFromUintArrayL(reinterpret_cast<RArray<TUint>&>(iSupportedFormats));
    TPckgBuf<TUint> pckg;
   	pckg() = iSupportedFormats.Count();
    aMessage.WriteDataToClientL(pckg);
	
    aMessage.Complete(status);
	}

// ---------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetNumOfSupportedToolsL(
// ---------------------------------------------------------
//
void CWmaDecoderIntfcMsgHdlr::DoGetNumOfSupportedToolsL(TMMFMessage& aMessage)
	{
	iSupportedTools.Reset();
	TInt status = iWmaDecoderIntfcCI->GetSupportedTools(iSupportedTools);
	CreateBufFromUintArrayL(reinterpret_cast<RArray<TUint>&>(iSupportedTools));

	TPckgBuf<TUint> pckg;
    pckg() = iSupportedTools.Count();
	aMessage.WriteDataToClientL(pckg);
    aMessage.Complete(status);
	}

// ---------------------------------------------------------
// CWmaDecoderIntfcMsgHdlr::DoGetNumOfControllableToolsL
// ---------------------------------------------------------
//
void CWmaDecoderIntfcMsgHdlr::DoGetNumOfControllableToolsL(TMMFMessage& aMessage)
	{
	iControllableTools.Reset();
	TInt status = iWmaDecoderIntfcCI->GetControllableTools(iControllableTools);
	CreateBufFromUintArrayL(reinterpret_cast<RArray<TUint>&>(iControllableTools));
	TPckgBuf<TUint> pckg;
    pckg() = iControllableTools.Count();
	aMessage.WriteDataToClientL(pckg); 
    aMessage.Complete(status);
	}



// End of File