--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/devsoundextensions/mmfcustominterfaces/SbcEncoderIntfc/SbcEncoderIntfcProxy/src/SbcEncoderIntfcProxy.cpp Tue Feb 02 01:56:55 2010 +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 <CustomCommandUtility.h>
+#include <CustomInterfaceUtility.h>
+#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<TUint>&
+ 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<TUint>& aSupportedSamplingFrequencies)
+ {
+ aSupportedSamplingFrequencies.Reset();
+
+ TPckgBuf<TUint> 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<TSbcChannelMode>&
+ 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<TSbcChannelMode>& aSupportedChannelModes)
+ {
+ aSupportedChannelModes.Reset();
+
+ TPckgBuf<TSbcChannelMode> 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.Append(
+ static_cast<TSbcChannelMode>(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<TUint>& 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<TUint>& aSupportedNumOfBlocks)
+ {
+ aSupportedNumOfBlocks.Reset();
+
+ TPckgBuf<TUint> 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<TUint>& 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<TUint>& aSupportedNumOfSubbands)
+ {
+ aSupportedNumOfSubbands.Reset();
+
+ TPckgBuf<TUint> 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<TSbcAllocationMethod>&
+ 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<TSbcAllocationMethod>&
+ aSupportedAllocationMethods)
+ {
+ aSupportedAllocationMethods.Reset();
+
+ TPckgBuf<TSbcAllocationMethod> 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.Append(
+ static_cast<TSbcAllocationMethod>(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<TSbcEncoderBitpoolRange> 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<TSbcEncoderConfig> 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<TUint>& aArray,
+ TPtr8 aPtr,
+ TUint aCount)
+ {
+ RDesReadStream stream(aPtr);
+ CleanupClosePushL(stream);
+
+ for (TInt i = 0; i < aCount; i++)
+ {
+ aArray.Append(stream.ReadUint32L());
+ }
+
+ CleanupStack::PopAndDestroy(&stream);
+ }
+
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+
+// End of File