diff -r 000000000000 -r bde4ae8d615e os/mm/devsoundextensions/mmfcustominterfaces/SbcEncoderIntfc/SbcEncoderIntfcProxy/src/SbcEncoderIntfcProxy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/devsoundextensions/mmfcustominterfaces/SbcEncoderIntfc/SbcEncoderIntfcProxy/src/SbcEncoderIntfcProxy.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,708 @@ +/* +* 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: Interface proxy for BT SBC Encoder configuration CI. +* +*/ + + + +// INCLUDE FILES +#include +#include +#include "SbcEncoderIntfcMsgs.h" +#include "SbcEncoderIntfcProxy.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 ============================== + +/** + * CSbcEncoderIntfcProxy::CSbcEncoderIntfcProxy + * C++ default constructor can NOT contain any code, that might leave. + */ +CSbcEncoderIntfcProxy::CSbcEncoderIntfcProxy( + TMMFMessageDestinationPckg aMessageHandler, + MCustomCommand& aCustomCommand, + CCustomInterfaceUtility* aCustomInterfaceUtility) : + iCustomCommand(aCustomCommand), + iMessageHandler(aMessageHandler), + iCustomInterfaceUtility(aCustomInterfaceUtility) + { + } + +/** + * CSbcEncoderIntfcProxy::ConstructL + * Symbian 2nd phase constructor can leave. + */ +void CSbcEncoderIntfcProxy::ConstructL() + { + iHasBeenApplied = EFalse; + } + +/** + * CSbcEncoderIntfcProxy::NewL + * Two-phased constructor. + */ +EXPORT_C CSbcEncoderIntfcProxy* CSbcEncoderIntfcProxy::NewL( + TMMFMessageDestinationPckg aMessageHandler, + MCustomCommand& aCustomCommand, + CCustomInterfaceUtility* aCustomInterfaceUtility) + { + CSbcEncoderIntfcProxy* self = new(ELeave) CSbcEncoderIntfcProxy( + aMessageHandler, + aCustomCommand, + aCustomInterfaceUtility); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +/** + * Destructor + */ +EXPORT_C CSbcEncoderIntfcProxy::~CSbcEncoderIntfcProxy() + { + iCustomInterfaceUtility->RemoveCustomInterface(iMessageHandler); + delete iCustomInterfaceUtility; + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedSamplingFrequencies + * Returns an array of supported sampling frequencies. + * Calls a subfunction, which sends the appropriate custom command + * to its message handler. A subfunction is used to contain multiple + * leaving functions in a single trap. + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedSamplingFrequencies( + RArray& + aSupportedSamplingFrequencies) + { + TRAPD(status, + GetSupportedSamplingFrequenciesL(aSupportedSamplingFrequencies)); + return status; + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedSamplingFrequenciesL + * Returns an array of supported sampling frequencies. + * Sends the custom command for this function to its message handler. This + * requires two commands. The first is a request for the number of supported + * sampling frequencies. A buffer is allocated locally to hold this number of + * frequencies that will be returned. A pointer to this buffer is sent with the + * next command, which is a request for the frequencies. This buffer will be + * filled with the frequency values. These values are then copied into the + * array provided to this function and the local buffer is deleted. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcProxy::GetSupportedSamplingFrequenciesL( + RArray& aSupportedSamplingFrequencies) + { + aSupportedSamplingFrequencies.Reset(); + + TPckgBuf pckgBuf; + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetNumOfSupportedSamplingFrequencies, + KNullDesC8, + KNullDesC8, + pckgBuf)); + + HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint)); + TPtr8 ptr = buf->Des(); + + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetSupportedSamplingFrequencies, + KNullDesC8, + KNullDesC8, + ptr)); + + PopulateArrayL(aSupportedSamplingFrequencies, ptr, pckgBuf()); + CleanupStack::PopAndDestroy(buf); + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedChannelModes + * Returns an array of supported channel modes. + * Calls a subfunction which sends the appropriate custom command to its + * message handler. A subfunction is used to contain multiple leaving + * functions for a single trap. + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedChannelModes( + RArray& + aSupportedChannelModes) + { + TRAPD(status, GetSupportedChannelModesL(aSupportedChannelModes)); + return status; + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedChannelModesL + * Returns an array of supported channel modes. + * Sends the custom command for this function to its message handler. This + * requires two commands. The first is a request for the number of supported + * channel modes. A buffer is allocated locally to hold this number of channel + * modes that will be returned. A pointer to this buffer is sent with the next + * command, which is a request for the channel modes. This buffer will be + * filled with the frequency values. These values are then copied into the array + * provided to this function and the local buffer is deleted. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcProxy::GetSupportedChannelModesL( + RArray& aSupportedChannelModes) + { + aSupportedChannelModes.Reset(); + + TPckgBuf pckgBuf; + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetNumOfSupportedChannelModes, + KNullDesC8, + KNullDesC8, + pckgBuf)); + + HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint)); + TPtr8 ptr = buf->Des(); + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetSupportedChannelModes, + KNullDesC8, + KNullDesC8, + ptr)); + + RDesReadStream stream(ptr); + CleanupClosePushL(stream); + + for (TInt i = 0; i < pckgBuf(); i++) + { + aSupportedChannelModes.AppendL( + static_cast(stream.ReadUint32L())); + } + + CleanupStack::PopAndDestroy(&stream); + CleanupStack::PopAndDestroy(buf); + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedNumOfBlocks + * Returns an array of supported blocks. + * Calls a subfunction, which sends the appropriate custom command to its + * message handler. A subfunction is used to contain multiple leaving functions + * for a single trap. + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedNumOfBlocks( + RArray& aSupportedNumOfBlocks) + { + TRAPD(status, GetSupportedNumOfBlocksL(aSupportedNumOfBlocks)); + return status; + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedNumOfBlocks + * Returns an array of supported blocks. + * Sends the custom command for this function to its message handler. This + * requires two commands. The first is a request for the number of supported + * blocks. A buffer is allocated locally to hold this number of blocks that + * will be returned. A pointer to this buffer is then sent with the next + * command, which is a request for the blocks. This buffer will be filled + * with the block values. These values are then copied into the array provided + * to this function and the local buffer is deleted. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcProxy::GetSupportedNumOfBlocksL( + RArray& aSupportedNumOfBlocks) + { + aSupportedNumOfBlocks.Reset(); + + TPckgBuf pckgBuf; + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetNumOfSupportedBlocks, + KNullDesC8, + KNullDesC8, + pckgBuf)); + + HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint)); + TPtr8 ptr = buf->Des(); + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetSupportedBlocks, + KNullDesC8, + KNullDesC8, + ptr)); + + PopulateArrayL(aSupportedNumOfBlocks, ptr, pckgBuf()); + CleanupStack::PopAndDestroy(buf); + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedNumOfSubbands + * Returns an array of supported subbands. + * Calls a subfunction which sends the appropriate custom command to its + * message handler. A subfunction is used to contain multiple leaving functions + * for a single trap. + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedNumOfSubbands( + RArray& aSupportedNumOfSubbands) + { + TRAPD(status, GetSupportedNumOfSubbandsL(aSupportedNumOfSubbands)); + return status; + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedNumOfSubbandsL + * Returns an array of supported subbands. + * Sends the custom command for this function to its message handler. This + * requires two commands. The first is a request for the number of supported + * subbands. A buffer is allocated locally to hold this number of subbands that + * will be returned. A pointer to this buffer is sent with the next command, + * which is a request for the subbands. This buffer will be filled with the + * subband values. These values are then copied into the array provided to this + * function and the local buffer is deleted. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcProxy::GetSupportedNumOfSubbandsL( + RArray& aSupportedNumOfSubbands) + { + aSupportedNumOfSubbands.Reset(); + + TPckgBuf pckgBuf; + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetNumOfSupportedNumOfSubbands, + KNullDesC8, + KNullDesC8, + pckgBuf)); + + HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint)); + TPtr8 ptr = buf->Des(); + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetSupportedNumOfSubbands, + KNullDesC8, + KNullDesC8, + ptr)); + + PopulateArrayL(aSupportedNumOfSubbands, ptr, pckgBuf()); + CleanupStack::PopAndDestroy(buf); + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedAllocationMethods + * Returns an array of supported allocation methods. + * Calls a subfunction which sends the appropriate custom command to its + * message handler. A subfunction is used to contain multiple leaving + * functions for a single trap. + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedAllocationMethods( + RArray& + aSupportedAllocationMethods) + { + TRAPD(status, GetSupportedAllocationMethodsL(aSupportedAllocationMethods)); + return status; + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedAllocationMethodsL + * Returns an array of supported allocation methods. + * Sends the custom command for this function to its message handler. This + * requires two commands. The first is a request for the number of supported + * allocation methods. A buffer is allocated locally to hold this number of + * allocation methods that will be returned. A pointer to this buffer is sent + * with the next command which is a request for the allocation methods. This + * buffer will be filled with the allocation method values. These values are + * then copied into the array provided to this function and the local buffer + * is deleted. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcProxy::GetSupportedAllocationMethodsL( + RArray& + aSupportedAllocationMethods) + { + aSupportedAllocationMethods.Reset(); + + TPckgBuf pckgBuf; + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetNumOfSupportedAllocationMethods, + KNullDesC8, + KNullDesC8, + pckgBuf)); + + HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint)); + TPtr8 ptr = buf->Des(); + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetSupportedAllocationMethods, + KNullDesC8, + KNullDesC8, + ptr)); + + RDesReadStream stream(ptr); + CleanupClosePushL(stream); + + for (TInt i = 0; i < pckgBuf(); i++) + { + aSupportedAllocationMethods.AppendL( + static_cast(stream.ReadUint32L())); + } + + CleanupStack::PopAndDestroy(&stream); + CleanupStack::PopAndDestroy(buf); + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedBitpoolRange + * Returns supported bitpool range. + * Calls a subfunction which sends the appropriate custom command to its + * message handler. A subfunction is used to contain multiple leaving + * functions for a single trap. + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedBitpoolRange( + TUint& aMinSupportedBitpoolSize, + TUint& aMaxSupportedBitpoolSize) + { + TRAPD(status, GetSupportedBitpoolRangeL(aMinSupportedBitpoolSize, + aMaxSupportedBitpoolSize)); + return status; + } + +/** + * CSbcEncoderIntfcProxy::GetSupportedBitpoolRangeL + * Returns an array of supported bitpool range. + * Sends the custom command for this function to its message handler with TUint + * type arguments that will be filled with the bitpool min and max values. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcProxy::GetSupportedBitpoolRangeL( + TUint& aMinSupportedBitpoolSize, + TUint& aMaxSupportedBitpoolSize) + { + TSbcEncoderBitpoolRange bitPoolRange; + bitPoolRange.iMinSupportedBitpoolSize = 0; + bitPoolRange.iMaxSupportedBitpoolSize = 0; + + TPckgBuf pckgBuf(bitPoolRange); + User::LeaveIfError(iCustomCommand.CustomCommandSync( + iMessageHandler, + ESbceimGetSupportedBitpoolRange, + KNullDesC8, + KNullDesC8, + pckgBuf)); + + aMinSupportedBitpoolSize = pckgBuf().iMinSupportedBitpoolSize; + aMaxSupportedBitpoolSize = pckgBuf().iMaxSupportedBitpoolSize; + } + +/* + * CSbcEncoderIntfcProxy::ApplyConfig + * Commits encoder configuration settings configured by callas to Set() APIs. + * Sends the custom command for this function to its message handler. + * New settings will not take effect until ApplyConfig() is called. + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::ApplyConfig() + { + TInt status = KErrNone; + + if (!iHasBeenApplied) + { + if (!iSbcEncConf.iSamplingFrequencySet || + !iSbcEncConf.iChannelModeSet || + !iSbcEncConf.iNumOfSubbandsSet || + !iSbcEncConf.iNumOfBlocksSet || + !iSbcEncConf.iAllocationMethodSet || + !iSbcEncConf.iBitpoolSizeSet) + { + status = KErrArgument; + } + } + + if (status == KErrNone) + { + TSbcEncoderConfig sbcEncoderConfig; + + sbcEncoderConfig.iSamplingFrequency = iSbcEncConf.iSamplingFrequency; + sbcEncoderConfig.iChannelMode = iSbcEncConf.iChannelMode; + sbcEncoderConfig.iNumOfSubbands = iSbcEncConf.iNumOfSubbands; + sbcEncoderConfig.iNumOfBlocks = iSbcEncConf.iNumOfBlocks; + sbcEncoderConfig.iAllocationMethod = iSbcEncConf.iAllocationMethod; + sbcEncoderConfig.iBitpoolSize = iSbcEncConf.iBitpoolSize; + + TPckgBuf pckgBuf(sbcEncoderConfig); + status = iCustomCommand.CustomCommandSync(iMessageHandler, + ESbceimApplyConfig, + pckgBuf, + KNullDesC8); + if (status == KErrNone) + { + iSbcEncConfCurrent = iSbcEncConf; + iHasBeenApplied = ETrue; + } + } + + return status; + } + +/** + * CSbcEncoderIntfcProxy::SetSamplingFrequency + * Saves locally requested sampling frequency. + * Change does not apply to the encoder until ApplyConfig() is called. + * (other items were commented in a header). + */ +EXPORT_C void CSbcEncoderIntfcProxy::SetSamplingFrequency( + TUint aSamplingFrequency) + { + iSbcEncConf.iSamplingFrequency = aSamplingFrequency; + iSbcEncConf.iSamplingFrequencySet = ETrue; + } + +/** + * CSbcEncoderIntfcProxy::GetSamplingFrequency + * Returns current sampling frequency commited by call to ApplyConfig(). + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetSamplingFrequency( + TUint& aSamplingFrequency) + { + TInt status = KErrNone; + + if (iHasBeenApplied) + { + aSamplingFrequency = iSbcEncConfCurrent.iSamplingFrequency; + } + else + { + status = KErrArgument; + } + + return status; + } + +/** + * CSbcEncoderIntfcProxy::SetChannelMode + * Saves locally requested channel mode. + * Change does not apply to the encoder until ApplyConfig() is called. + * (other items were commented in a header). + */ +EXPORT_C void CSbcEncoderIntfcProxy::SetChannelMode( + TSbcChannelMode aChannelMode) + { + iSbcEncConf.iChannelMode = aChannelMode; + iSbcEncConf.iChannelModeSet = ETrue; + } + +/** + * CSbcEncoderIntfcProxy::GetChannelMode + * Returns current channel mode commited by call to ApplyConfig(). + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetChannelMode( + TSbcChannelMode& aChannelMode) + { + TInt status = KErrNone; + + if (iHasBeenApplied) + { + aChannelMode = iSbcEncConfCurrent.iChannelMode; + } + else + { + status = KErrArgument; + } + + return status; + } + +/** + * CSbcEncoderIntfcProxy::SetNumOfSubbands + * Saves locally requested number of subbands. + * Change does not apply to the encoder until ApplyConfig() is called. + * (other items were commented in a header). + */ +EXPORT_C void CSbcEncoderIntfcProxy::SetNumOfSubbands(TUint aNumOfSubbands) + { + iSbcEncConf.iNumOfSubbands = aNumOfSubbands; + iSbcEncConf.iNumOfSubbandsSet = ETrue; + } + +/** + * CSbcEncoderIntfcProxy::GetNumOfSubbands + * Returns current number of subbands commited by call to ApplyConfig(). + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetNumOfSubbands(TUint& aNumOfSubbands) + { + TInt status = KErrNone; + + if (iHasBeenApplied) + { + aNumOfSubbands = iSbcEncConfCurrent.iNumOfSubbands; + } + else + { + status = KErrArgument; + } + + return status; + } + +/** + * CSbcEncoderIntfcProxy::SetNumOfBlocks + * Saves locally requested number of blocks. + * Change does not apply to the encoder until ApplyConfig() is called. + * (other items were commented in a header). + */ +EXPORT_C void CSbcEncoderIntfcProxy::SetNumOfBlocks(TUint aNumOfBlocks) + { + iSbcEncConf.iNumOfBlocks = aNumOfBlocks; + iSbcEncConf.iNumOfBlocksSet = ETrue; + } + +/** + * CSbcEncoderIntfcProxy::GetNumOfBlocks + * Returns current number of blocks commited by call to ApplyConfig(). + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetNumOfBlocks(TUint& aNumOfBlocks) + { + TInt status = KErrNone; + + if (iHasBeenApplied) + { + aNumOfBlocks = iSbcEncConfCurrent.iNumOfBlocks; + } + else + { + status = KErrArgument; + } + + return status; + } + +/** + * CSbcEncoderIntfcProxy::SetAllocationMethod + * Saves locally requested allocation method. + * Change does not apply to the encoder until ApplyConfig() is called. + * (other items were commented in a header). + */ +EXPORT_C void CSbcEncoderIntfcProxy::SetAllocationMethod( + TSbcAllocationMethod aAllocationMethod) + { + iSbcEncConf.iAllocationMethod = aAllocationMethod; + iSbcEncConf.iAllocationMethodSet = ETrue; + } + +/** + * CSbcEncoderIntfcProxy::GetAllocationMethod + * Returns current allocation method commited by call to ApplyConfig(). + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetAllocationMethod( + TSbcAllocationMethod& aAllocationMethod) + { + TInt status = KErrNone; + + if (iHasBeenApplied) + { + aAllocationMethod = iSbcEncConfCurrent.iAllocationMethod; + } + else + { + status = KErrArgument; + } + + return status; + } + +/** + * CSbcEncoderIntfcProxy::SetBitpoolSize + * Saves locally requested bitpool range. + * Change does not apply to the encoder until ApplyConfig() is called. + * (other items were commented in a header). + */ +EXPORT_C void CSbcEncoderIntfcProxy::SetBitpoolSize(TUint aBitpoolSize) + { + iSbcEncConf.iBitpoolSize = aBitpoolSize; + iSbcEncConf.iBitpoolSizeSet = ETrue; + } + +/** + * CSbcEncoderIntfcProxy::GetBitpoolSize + * Returns current bitpool range commited by call to ApplyConfig(). + * (other items were commented in a header). + */ +EXPORT_C TInt CSbcEncoderIntfcProxy::GetBitpoolSize(TUint& aBitpoolSize) + { + TInt status = KErrNone; + + if (iHasBeenApplied) + { + aBitpoolSize = iSbcEncConfCurrent.iBitpoolSize; + } + else + { + status = KErrArgument; + } + + return status; + } + +/** + * CSbcEncoderIntfcProxy::PopulateArrayL + * Utility method that reads stream from 8-bit descriptor, converts it + * to TUint data items and then copies them to the aArray. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcProxy::PopulateArrayL(RArray& aArray, + TPtr8 aPtr, + TUint aCount) + { + RDesReadStream stream(aPtr); + CleanupClosePushL(stream); + + for (TInt i = 0; i < aCount; i++) + { + aArray.AppendL(stream.ReadUint32L()); + } + + CleanupStack::PopAndDestroy(&stream); + } + +// ========================== OTHER EXPORTED FUNCTIONS ========================= + +// End of File