Symaptic: os/mm/mm_plat/sbc_encoder_interface_api/inc/SbcEncoderIntfc.h@260cb5ec6c19

     1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Interface definition for BT SBC Encoder configuration.

    15 *

    16 */

    19 #ifndef CSBCENCODERINTFC_H

    20 #define CSBCENCODERINTFC_H

    22 // INCLUDES

    23 #include <e32base.h>

    25 // CONSTANTS

    26 const TUid KUidSbcEncoderIntfc = {0x10207B24};

    28 // MACROS

    30 // DATA TYPES

    32 // FUNCTION PROTOTYPES

    34 // FORWARD DECLARATIONS

    35 class CMMFDevSound;

    36 class CMdaAudioInputStream;

    38 // CLASS DECLARATION

    40 /**

    41 *  Interface for configuring the SBC encoder.

    42 *  Used to configure the SBC encoder operating modes.

    43 *  This abstract class just provides the static NewL function for the creation

    44 *  of the proxy, and also defines the custom interface to be implemented by the

    45 *  proxy and the real custom interface implementation.

    46 *

    47 *  @lib SbcEncoderIntfc.lib

    48 *  @since S60 3.0

    49 */

    50 class CSbcEncoderIntfc : public CBase

    51 	{

    52     public: // Data

    54     // Supported channel modes

    55     enum TSbcChannelMode

    56         {

    57         ESbcChannelMono,

    58         ESbcChannelDual,

    59         ESbcChannelStereo,

    60         ESbcChannelJointStereo

    61         };

    63     // Supported allocation methods

    64     enum TSbcAllocationMethod

    65         {

    66         ESbcAllocationSNR,

    67         ESbcAllocationLoudness

    68         };

    70     public:  // Constructors and destructor

    72         /**

    73         * Creates the interface.

    74         */

    75 		IMPORT_C static CSbcEncoderIntfc* NewL(CMMFDevSound& aDevSound);

    77         /**

    78         * Creates the interface.

    79         */

    80 		IMPORT_C static CSbcEncoderIntfc* NewL(CMdaAudioInputStream& aUtility);

    82     public: // New functions

    83         /**

    84         * Retrieves the sampling frequencies supported by the encoder.

    85         * @since S60 3.0

    86         * @param aSupportedSamplingFrequencies array returning the supported

    87         *        frequencies.

    88         * @return TInt status

    89         */

    90 		IMPORT_C virtual TInt GetSupportedSamplingFrequencies(

    91 		                      RArray<TUint>& aSupportedSamplingFrequencies) = 0;

    93         /**

    94         * Retrieves the channel configurations supported by the encoder.

    95         * @since S60 3.0

    96         * @param aSupportedChannelModes array returning the supported

    97         *        frequencies.

    98         * @return TInt status

    99         */

   100 		IMPORT_C virtual TInt GetSupportedChannelModes(

   101 		                      RArray<TSbcChannelMode>&

   102 		                      aSupportedChannelModes) = 0;

   104         /**

   105         * Retrieves array of supported block numbers by the encoder.

   106         * @since S60 3.0

   107         * @param aNumBlocks array returning block numbers.

   108         * @return TInt status

   109         */

   110 		IMPORT_C virtual TInt GetSupportedNumOfBlocks(

   111 		                      RArray<TUint>& aSupportedNumOfBlocks) = 0;

   113         /**

   114         * Retrieves the number of subbands supported by the encoder.

   115         * @since S60 3.0

   116         * @param aSupportedNumOfSubbands array returning the supported number

   117         *        of subbands.

   118         * @return TInt status

   119         */

   120 		IMPORT_C virtual TInt GetSupportedNumOfSubbands(

   121 		                      RArray<TUint>& aSupportedNumOfSubbands) = 0;

   123         /**

   124         * Retrieves the allocation methods supported by the encoder.

   125         * @since S60 3.0

   126         * @param aSupportedAllocationMethods array returning the supported

   127         *        allocation methods.

   128         * @return TInt status

   129         */

   130 		IMPORT_C virtual TInt GetSupportedAllocationMethods(

   131 		                      RArray<TSbcAllocationMethod>&

   132 		                      aSupportedAllocationMethods) = 0;

   134         /**

   135         * Retrieves the supported bitpool range by the encoder.

   136         * @since S60 3.0

   137         * @param aMinSupportedBitpoolSize returning the min bitpool size.

   138         * @param aMaxSupportedBitpoolSize returning the max bitpool size.

   139         * @return TInt status

   140         */

   141 		IMPORT_C virtual TInt GetSupportedBitpoolRange(

   142 		                      TUint& aMinSupportedBitpoolSize,

   143 		                      TUint& aMaxSupportedBitpoolSize) = 0;

   145         /**

   146         * Sets the sampling frequency for encoding.

   147         * @since S60 3.0

   148         * @param aSamplingFrequency requested encoding sampling frequency.

   149         * @return void

   150         */

   151 		IMPORT_C virtual void SetSamplingFrequency(

   152 		                      TUint aSamplingFrequency) = 0;

   154         /**

   155         * Retrieves the current encode sampling frequency.

   156         * @since S60 3.0

   157         * @param aSamplingFrequency returns current encode sampling frequency.

   158         * @return TInt status

   159         */

   160 		IMPORT_C virtual TInt GetSamplingFrequency(

   161 		                      TUint& aSamplingFrequency) = 0;

   163         /**

   164         * Sets the channel mode for encoding.

   165         * @since S60 3.0

   166         * @param aChannelMode requested encoding channel mode.

   167         * @return void

   168         */

   169 		IMPORT_C virtual void SetChannelMode(

   170 		                      TSbcChannelMode aChannelMode) = 0;

   172         /**

   173         * Retrieves the current encode channel mode.

   174         * @since S60 3.0

   175         * @param aChannelMode returns current encode channel mode.

   176         * @return TInt status

   177         */

   178 		IMPORT_C virtual TInt GetChannelMode(

   179 		                      TSbcChannelMode& aChannelMode) = 0;

   181         /**

   182         * Sets the number of subbands for encoding.

   183         * @since S60 3.0

   184         * @param aNumofSubbands requested encoding number of subbands.

   185         * @return void

   186         */

   187 		IMPORT_C virtual void SetNumOfSubbands(TUint aNumOfSubbands) = 0;

   189         /**

   190         * Retrieves the current encode number of subbands.

   191         * @since S60 3.0

   192         * @param aNumOfSubbands returns current encode number of subbands.

   193         * @return TInt status

   194         */

   195 		IMPORT_C virtual TInt GetNumOfSubbands(TUint& aNumOfSubbands) = 0;

   197         /**

   198         * Sets the number of blocks for encoding.

   199         * @since S60 3.0

   200         * @param aNumOfBlocks requested encoding number of blocks.

   201         * @return void

   202         */

   203 		IMPORT_C virtual void SetNumOfBlocks(TUint aNumOfBlocks) = 0;

   205         /**

   206         * Retrieves the current encode number of blocks.

   207         * @since S60 3.0

   208         * @param aNumOfBlocks returns current encode number of blocks.

   209         * @return TInt status

   210         */

   211 		IMPORT_C virtual TInt GetNumOfBlocks(TUint& aNumOfBlocks) = 0;

   213         /**

   214         * Sets the allocation method for encoding.

   215         * @since S60 3.0

   216         * @param aAllocationMethod requested encoding allocation method.

   217         * @return void

   218         */

   219 		IMPORT_C virtual void SetAllocationMethod(

   220 		                      TSbcAllocationMethod aAllocationMethod) = 0;

   222         /**

   223         * Retrieves the current encode allocation method.

   224         * @since S60 3.0

   225         * @param aAllocationMethod returns current encode allocation method.

   226         * @return TInt status

   227         */

   228 		IMPORT_C virtual TInt GetAllocationMethod(

   229 		                      TSbcAllocationMethod& aAllocationMethod) = 0;

   231         /**

   232         * Sets the bitpool size for encoding.

   233         * @since S60 3.0

   234         * @param aBitpoolSize requested encoding number of blocks.

   235         * @return void

   236         */

   237 		IMPORT_C virtual void SetBitpoolSize(TUint aBitpoolSize) = 0;

   239         /**

   240         * Retrieves the current encode bitpool size.

   241         * @since S60 3.0

   242         * @param aBitpoolSize returns current encode bitpool size.

   243         * @return TInt status

   244         */

   245 		IMPORT_C virtual TInt GetBitpoolSize(TUint& aBitpoolSize) = 0;

   247         /**

   248         * Applies configuration to the encoder.

   249         * @since S60 3.0

   250         * @return TInt - status

   251         */

   252 		IMPORT_C virtual TInt ApplyConfig() = 0;

   254 	};

   256 #endif      // CSBCENCODERINTFC_H

   258 // End of File

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--